Mehmet Baykal

seyahat python programming kitap alinti

Threading in C#, by Joe Albahari

GETTING STARTED
Introduction and Concepts
Join and Sleep
How Threading Works
Threads vs Processes
Threading’s Uses and Misuses
Creating and Starting Threads
Passing Data to a Thread
Naming Threads
Foreground vs Background
Thread Priority
Exception Handling
Thread Pooling
Thread Pooling via TPL
Thread Pooling Without TPL
Optimizing the Thread Pool
BASIC SYNCHRONIZATION
+ Synchronization Essentials
+ Locking
+ Thread Safety
+ Event Wait Handles
+ Synchronization Contexts
USING THREADS
+ Event-Based Asynch Pattern
+ BackgroundWorker
+ Interrupt and Abort
+ Safe Cancellation
+ Lazy Initialization
+ Thread-Local Storage
+ Timers
ADVANCED THREADING
+ Nonblocking Synchronization
+ Signaling with Wait and Pulse
+ The Barrier Class
+ Reader/Writer Locks
+ Suspend and Resume
+ Aborting Threads
PARALLEL PROGRAMMING
+ Parallel Programming
+ Why PFX?
+ PLINQ
+ The Parallel Class
+ Task Parallelism
+ Working with AggregateException
+ Concurrent Collections
+ SpinLock and SpinWait

http://www.albahari.com/threading/

OO Fundamental & Principles & Software Design Patterns

Fundamental OOPS Concepts
--Abstraction
--Encapsulation
--Inheritance
--Polymorphism
----Types of Polymorphism
----Design Vs Run time polymorphism
----Need of Function Overloading
----Overloading by Return Type ?
--Messaging
--Extensibility 
--Persistence
--Delegation 
--Genericity
--Multiple Inheritance 
--Principles
--Single Responsibility
--Open Closed
--Liskov Substitution
--Interface Segregation
--Dependency Inversion
--Don't Repeat YourSelf
--Law of Demeter
--Hollywood
--KISS
--Yagni
--Tell, don’t ask

Software Design Patterns
  --Creational Patterns
----Abstract Factory
----Builder
----Factory Method
----Prototype
----Singleton
----Inversion of Control
----Dependency Injection
----Service Locator
----Object Pool
--Structural Patterns
----Adapter
----Bridge
----Composite
----Decorator
----Facade
----Flyweight
 ----Proxy
 ----Interception
----Property Map
----Private Class Data
----Value Object
----Money
----Special Case
----Null Object
--Behavioral Patterns
----Chain of Responsibility
----Command
----Interpreter
----Iterator
----Mediator
----Memento
----Observer
----State
----Strategy
----Template Method
----Visitor
----Event Aggregator

Application Patterns
--Generic Base Patterns
----Mapper Pattern
----Separated Interface Pattern
--Domain Logic Patterns
----Transaction Script
----Table Module
----Domain Model
----Service Layer
--Data Access Patterns
----Active Record
----Row Data Gateway
----Table Data Gateway
----Data Mapper
----Record Set
----ORM Patterns
------Behavioral ORM Patterns
--------Unit of Work
--------Identity Map
--------Lazy Load
------Structural ORM Patterns
--------Identıty Field
--------Foreign Key Map
--------Association Table Mapping
 --------Dependent Mapping
 --------Embedded Value
 --------Serialized LOB
 --------Single Table Inheritance
 --------Class Table Inheritance
 --------Concrete Table Inheritance
 --------Inheritance Mappers
 -------Metadata ORM Patterns
 --------Metadata Mapping Pattern
 --------Query Object Pattern
 --------Repository Pattern

Presentation Patterns
--Client Presentation
--Web Presentation
Distribution Patterns
Integration Patterns
Offline Concurrency Patterns
Session State Patterns
Extensibility Patterns

Her Developerın Okuması Gereken Kitaplar

Clean Code - Robert C. Martin
Design Patterns - Head First 
Patterns of Enterprise Application Architecture - Martin Fowler
Test-Driven Development - Kent Beck
97 Things Every Programmer Should Know - Kevlin Henney
Domain Driven Design with C Sharp - Wrox
Adaptive Code via C# - Gary McLean Hall

Gang of Four Design Patterns

Creational Patterns

  • *Abstract Factory: Creates an instance of several families of classes. For example; MsSqlAdapter, MsSqlConnection, MsSqlCommand - OracleAdapter, OracleConnection, OracleCommand.
  • *Builder: Separates object construction from its representation. For example; you are reading data from db and preparing two different output file format, an EDI file(yuo have a class for every edi keyword) and a xml file.
  • *Factory Method: Creates an instance of several derived classes. For example; there is a vehicle factory and it manufacture bike and motobike. You can request product from factory with vehicle type.
  • *Prototype: A fully initialized instance to be copied or cloned
  • *Singleton: A class of which only a single instance can exist

Structural Patterns

  • *Adapter: Match interfaces of different classes. The adapter pattern is a design pattern that is used to allow two incompatible types to communicate. Where one class relies upon a specific interface that is not implemented by another class, the adapter acts as a translator between the two types.
  • *Bridge: Separates an object’s interface from its implementation. The bridge pattern is a design pattern that separates the abstract elements of a class from its technical implementation. This provides a cleaner implementation of real-world objects and allows the implementation details to be changed easily.
  • *Composite: A tree structure of simple and composite objects. For example; MessageSenderBase, MailSender, SmsSender etc...
  • *Decorator: Add responsibilities to objects dynamically. For example; adding additioanal things when making a coffee, and price increases as you add new things. Or Pizza Decorator
  • *Facade: A single class that represents an entire subsystem
  • *Flyweight: A fine-grained instance used for efficient sharing
  • *Proxy: An object representing another object. For example; calling a web service from a desktop app, you should create a proxy to secure the service and coming data, wrapping DTO etc

Behavioral Patterns

  • *Chain of Resp.: A way of passing a request between a chain of objects. For exaple; thre are some object they are linked to eachother, there are some common mehtods to work.
  • *Command: Encapsulate a command request as an object
  • *Interpreter: A way to include language elements in a program. For example; interpret a predefined math arithmetic operation.
  • *Iterator: Sequentially access the elements of a collection
  • *Mediator: Defines simplified communication between classes. For example; publish - subscribe mechanism
  • *Memento: Capture and restore an object's internal state. For example; undu redo operations
  • *Observer: A way of notifying change to a number of classes
  • *State: Alter an object's behavior when its state changes. For example; managing the objects status.
  • *Strategy: Encapsulates an algorithm inside a class. For example; changing the behaviour like changing the using sorting algorithm with another one.
  • *Template Method: Defer the exact steps of an algorithm to a subclass. This pattern is used to define the basic steps of an algorithm and allow the implementation of the individual steps to be changed. This pattern looks similar to the strategy design pattern. The main difference is the ability to change the parts of an algorithm rather than replacing an entire algorithm. For example; when you call Save method, it actualy calls OnCanSave,OnSave, OnPostSave methods of the concurude class.
  • *Visitor: Defines a new operation to a class without change. For example; visits the all nodes of the given tree.

WPF Eğitim Konu İçerigi

Kısım 1

Wpf Mimarisi 
Logical Tree - Visual Tree 
Routing Event, Event Bubbling, Tunneling 
Window vs Page 
Application Nesnesi 
Layout Kontroller 
Style, Trigger, DataTemplate, Thema
Kısım 2

Binding Command, DelegateCommand 
Converter 
MarkupExtension 
INotifyPropertchanged, ObservableCollection 
Validation Dependency Object - Dependency Property 
Attached Property 
Custom Component 
Visual Inheritance 
MVVM Pattern 
UIThread vs BackgroundThread 
Kısım 3

WinForm Entegrasyonu 
Virtualizing
WPF Client Frameworkler 
Moduler Bir ERP Gelistirme 
Region Manager Command 
Manager Screen
Mediator Pattern

Alinti - The Architect Manifesto

We, IT architects, guide the design and evolution of computer systems. We strive to achieve maximum value for our business partners through this work. We constantly discover better ways to architect systems. As a result, we have come to value:

  • Simplicity over complexity
  • Pragmatism over perfectionism
  • Thinking out of the box over applying the same approaches to every problem
  • Developing technology agnostic solutions over making technology driven decisions
  • Delivering solutions to the business problems over concentrating purely on technology deliverables
  • Looking at the big picture over getting too deep into details
  • Long term, strategic thinking over short term, tactical thinking

That is, while there is a place for the tactics on the right, we should strive towards approaches on the left.