Design Patterns - Factory Method C#

Creational -> Factory Method

Das FactoyMethod Pattern definiert ein interface zur Erstellung von Objekten, die selbst entscheiden welche Subklassen Sie instanzieren.

Beispiel:

 class Program
    {
        static void Main(string[] args)
        {

            var cupCakes = new ICupCake[2];

            cupCakes[0] = new CherryCake();

            cupCakes[1] = new StrawberryCake();

            foreach (var cupCake in cupCakes)
            {
                Console.WriteLine(cupCake.GetType().Name);
                List<Fixings> list = cupCake.GetFixings();
                foreach (var fixing in list)
                {
                    Console.WriteLine("-- " + fixing.Name);
                }
            }

        }
    }

    public interface ICupCake
    {
        List<Fixings> GetFixings();
    }

    class CherryCake : ICupCake
    {
        readonly List<Fixings> _fixings = new List<Fixings>();

        public CherryCake()
        {
            _fixings.Add(new Fixings { Name = "Cherries" });
        }

        public List<Fixings> GetFixings()
        {
            return _fixings;
        }
    }

    class StrawberryCake : ICupCake
    {
        readonly List<Fixings> _fixings = new List<Fixings>();

        public StrawberryCake()
        {
            _fixings.Add(new Fixings { Name = "Strawberries" });
        }

        public List<Fixings> GetFixings()
        {
            return _fixings;
        }
    }

    public class Fixings
    {
        public string Name;
    }

Design Pattern - Singleton C#

Creational -> Singleton

Das Singleton Pattern stellt sicher, dass es vom gewünschten Objekt nur eine Instanz gibt und diese Global zu erreichen ist.

Beispiel:

class Program
    {
        static void Main(string[] args)
        {
            Overlord overlord1 = Overlord.GetOverlord();
            Overlord overlord2 = Overlord.GetOverlord();
            Overlord overlord3 = Overlord.GetOverlord();
            Overlord overlord4 = Overlord.GetOverlord();

            // Same instance?
            if (overlord1 == overlord2 && overlord2 == overlord3 && overlord3 == overlord4)
            {
                Console.WriteLine("Same overlord!");
            }


            // Summon 15 minions

            Overlord overlord = Overlord.GetOverlord();

            for (int i = 0; i < 15; i++)
            {
                var server = overlord.Minion;
                Console.WriteLine("Command your minion: " + server);
            }

            Console.ReadKey();

        }
    }


    class Overlord
    {
        private static Overlord _instance;
        private List<string> _minions = new List<string>();
        private Random _randomMinion = new Random();

        private static object syncLock = new object();
 
        // protected constructor
        protected Overlord()
        {
            _minions.Add("Minion1");
            _minions.Add("Minion2");
            _minions.Add("Minion3");
            _minions.Add("Minion4");
            _minions.Add("Minion5");
        }

        public static Overlord GetOverlord()
        {

          if (_instance == null)
          {
 
            lock (syncLock)
            {
 
              if (_instance == null)
              {
                _instance = new Overlord();
              }
            }
          }

          return _instance;
        }

        public string Minion
        {
          get
          {
            int random = _randomMinion.Next(_minions.Count);
            return _minions[random];
          }
        }
      }

Design Patterns - Abstract Factory C#

Creational -> Abstract Factory

Die Abstract Factory implementiert eine Schnittstelle zur Erzeugung von ähnlichen und/oder abhängigen Objektgruppen ohne diese direkt anzugeben oder zu kennen.

Hauptklasse:

1:  class Program  
2:    {  
3:      static void Main(string[] args)  
4:      {  
5:        // Factory #2  
6:        Abstract.AbstractFactory factory1 = new ConcreteFactory1();  
7:        var c1 = new Program(factory1);  
8:        c1.Run();  
9:        // Factory #1  
10:        Abstract.AbstractFactory factory2 = new ConcreteFactory2();  
11:        var c2 = new Program(factory2);  
12:        c2.Run();  
13:        Console.Read();  
14:      }  
15:      public Program(Abstract.AbstractFactory factory)  
16:      {  
17:        _abstractProductA = factory.CreateProductA();  
18:        _abstractProductB = factory.CreateProductB();  
19:      }  
20:      public void Run()  
21:      {  
22:        _abstractProductB.Interact(_abstractProductA);  
23:      }  
24:      private readonly AbstractProductA _abstractProductA;  
25:      private readonly AbstractProductB _abstractProductB;  
26:    }  

AbstractFactory.cs

1:  namespace AbstractFactory.Abstract  
2:  {  
3:    abstract class AbstractFactory  
4:    {  
5:      public abstract AbstractProductA CreateProductA();  
6:      public abstract AbstractProductB CreateProductB();  
7:    }  
8:  }  

AbstractProductA.cs

1:  namespace AbstractFactory.Abstract  
2:  {  
3:    abstract class AbstractProductA  
4:    {  
5:    }  
6:  }  

AbstractProductB.cs

1:  namespace AbstractFactory.Abstract  
2:  {  
3:    abstract class AbstractProductB  
4:    {  
5:      public abstract void Interact(AbstractProductA a);  
6:    }  
7:  }  

ConcreteFactory1.cs

1:  using AbstractFactory.Abstract;  
2:  using AbstractFactory.Product;  
3:  namespace AbstractFactory.Concrete  
4:  {  
5:    class ConcreteFactory1 : Abstract.AbstractFactory  
6:    {  
7:      public override AbstractProductA CreateProductA()  
8:      {  
9:        return new ProductA1();  
10:      }  
11:      public override AbstractProductB CreateProductB()  
12:      {  
13:        return new ProductB1();  
14:      }  
15:    }  
16:  }  

ConcreteFactory2.cs

1:  using AbstractFactory.Abstract;  
2:  using AbstractFactory.Product;  
3:  namespace AbstractFactory.Concrete  
4:  {  
5:    class ConcreteFactory2 : Abstract.AbstractFactory  
6:    {  
7:      public override AbstractProductA CreateProductA()  
8:      {  
9:        return new ProductA2();  
10:      }  
11:      public override AbstractProductB CreateProductB()  
12:      {  
13:        return new ProductB2();  
14:      }  
15:    }  
16:  }  

AbstractProductA1.cs

1:  using AbstractFactory.Abstract;  
2:  namespace AbstractFactory.Product  
3:  {  
4:    class ProductA1 : AbstractProductA  
5:    {  
6:    }  
7:  }  

AbstractProductA2.cs

1:  using AbstractFactory.Abstract;  
2:  namespace AbstractFactory.Product  
3:  {  
4:    class ProductA2 : AbstractProductA  
5:    {  
6:    }  
7:  }  

AbstractProductB1.cs

1:  using System;  
2:  using AbstractFactory.Abstract;  
3:  namespace AbstractFactory.Product  
4:  {  
5:    class ProductB1 : AbstractProductB  
6:    {  
7:      public override void Interact(AbstractProductA a)  
8:      {  
9:        Console.WriteLine(GetType().Name + " interacts with " + a.GetType().Name);  
10:      }  
11:    }  
12:  }  

AbstractProductB2.cs

1:  using System;  
2:  using AbstractFactory.Abstract;  
3:  namespace AbstractFactory.Product  
4:  {  
5:    class ProductB2 : AbstractProductB  
6:    {  
7:      public override void Interact(AbstractProductA a)  
8:      {  
9:        Console.WriteLine(GetType().Name + " interacts with " + a.GetType().Name);  
10:      }  
11:    }  
12:  }  

Verwaltete Metadaten nicht nutzbar. Taxonomy Feature kann nicht aktiviert werden.

Erstellt man eine SiteCollection mit dem "Leere Website" Template kann man verwaltete Metadaten zunächst nicht nutzen, da das Taxonomy Feature nicht aktiviert ist. Schaut man in die Site Features Verwaltung, ist das Feature nicht aufgelistet, kann jedoch über die Powershell aktiviert werden.

Enable-SPFeature -id 73EF14B1-13A9-416b-A9B5-ECECA2B0604C -URL http://mySiteCollection

Jetzt kann wie gewünscht die Spalte "Verwaltete Metadaten" verwendet werden.

101 SharePoint Code Samples

Jeden Tag ist man als SharePoint Entwickler wiederkehrenden Aufgaben gegenübergestellt. Einige solcher Aufgaben wurden in 101 Code Samples zusammengefasst.

http://code.msdn.microsoft.com/SharePoint-2010-101-Code-da251182

Fehlermeldung: Sie müssen einen Wert für dieses Pflichtfeld angeben

Diese Fehlermeldung kommt auf, wenn man beim Branding in der .master einen placeHolder mit visible=false ausblendet. Auskommentieren von placeHoldern verursacht den gleichen Fehler.
Um das problem zu umgehen kann man placeHolder mit style="display:none" ausblenden.

LINQ Abfragen beschleunigen

1. DataContext auf das nötigste beschränken

Legt euren DataContext nicht auf die komplette Datenbank. Behandelt Ihn je nach gebraucht. Man kann trotzdem noch den gleichen Datenbankvebrindungs String benutzen.

2.  Object Tracking abschalten

Wenn es nicht genutzt wird: abschalten!

using (NorthwindDataContext context = new NorthwindDataContext())
{
  context.ObjectTrackingEnabled = false;
}

3. CompiledQuery benutzen

Wandelt eure Querys in Compiled Querys um. Beim ersten aufruf werden diese compiled und man kann Sie in einer static Variable weiter nutzen.

Func<MyDatabaseDataContext, IEnumerable<MyTable>> func =
CompiledQuery.Compile<MyDatabaseDataContext, IEnumerable<MyTable>>
   ((MyDatabaseDataContext context) => context.MyTables.
      Where<MyTable>(x => x.MyProperty > someValue));

4. DataLoadOptions benutzen

DataLoadOptions options = new DataLoadOptions();
  options.AssociateWith<Mytable>( x => x.MyPropery.Where<MyProperty>(y => !y.Available));
  context.LoadOptions = options;

5. Nur das Laden, was benötigt wird

context.Products
           .Take<Product>(pageSize)
           .Skip<Product>(startingPageIndex * pageSize)
           .ToList<Product>();