Abstract Factory pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.

E.g. I have a DocumentFactory class that either returns DefaultDocumentFactory or CustomDocumentFactory dependening on the environment variable.

using System;
using System.Collections.Generic;
using System.Text;

namespace AbstractFactory
{
    abstract class DocumentFactory
    {
        public static DocumentFactory GetFactory()
        {
            string documentType =
             System.Environment.GetEnvironmentVariable("DOC_TYPE");
            if (documentType == null || documentType == "")
            {
                return new DefaultDocumentFactory();
            }
            else
            {
                return new CustomDocumentFactory();
            }
        }

        public abstract Document CreateDocument();
    }
}

DefaultDocumentFactory

using System;
using System.Collections.Generic;
using System.Text;

namespace AbstractFactory
{
    class DefaultDocumentFactory: DocumentFactory
    {
        public override Document CreateDocument()
        {
            return new DefaultDocument();
        }
    }
}

CustomDocumentFactory

using System;
using System.Collections.Generic;
using System.Text;

namespace AbstractFactory
{
    class CustomDocumentFactory: DocumentFactory
    {
        public override Document CreateDocument()
        {
            return new CustomDocument();
        }
    }
}

Document, DefaultDocument and CustomDocument are defined.

using System;
using System.Collections.Generic;
using System.Text;

namespace AbstractFactory
{
    abstract class Document
    {
      public string content;

        public String Content
        {
            get
            {
                return this.content;
            }
            set
            {
                this.content = value;
            }

        }

        public void Print()
        {
            Console.WriteLine(content);
        }

        public abstract void Write();

    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace AbstractFactory
{
    class DefaultDocument: Document
    {
        public override void Write()
        {
            this.Content = "Default Document";
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace AbstractFactory
{
    class CustomDocument:Document
    {
        public override void Write()
        {
            this.Content = "Custom Document";
        }
    }
}

To test it,

using System;
using System.Collections.Generic;
using System.Windows.Forms;

namespace AbstractFactory
{
    static class Program
    {
        /// 

        /// The main entry point for the application.
        /// 
        [STAThread]
        static void Main()
        {
            DocumentFactory  factory = DocumentFactory.GetFactory();
            Document document = factory.CreateDocument();
            document.Write();
            document.Print();
            Console.Read();
        }
    }
}

The output

Default Document

Factory Method Pattern defines an interface for creating an object, but let subclasses decide which class to instantiate. It lets a class defer instantiation to subclasses.

E.g., I defined a abstract News class.

using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryPattern
{
    abstract class News
    {
    }
}

Different kinds of news are defined..

using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryPattern
{
    class AdNews:News
    {
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryPattern
{
    class FashionNews:News
    {
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryPattern
{
    class FinanceNews:News
    {
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryPattern
{
    class SportsNews:News
    {
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryPattern
{
    class WorldNews:News
    {
    }
}

I defined the abstract factory class, Publication

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace FactoryPattern
{
    abstract class Publication
    {
        private ArrayList publishedNews = new ArrayList();

        // Constructor calls abstract Factory method
        public Publication()
        {
            this.PublishNews();
        }

        public ArrayList PublishedNews
        {
            get
            {
                return publishedNews;
            }
        }

        // Factory Method
        public abstract void PublishNews();
    }
}

In the Publication class, the factory method is called, but it is not implemented yet.

Newspaper and FashionMagazine extends Publication class.

using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryPattern
{
    class NewsPaper:Publication
    {
        public override void PublishNews()
        {
            this.PublishedNews.Add(new AdNews());
            this.PublishedNews.Add(new FashionNews());
            this.PublishedNews.Add(new WorldNews());
            this.PublishedNews.Add(new SportsNews());
            this.PublishedNews.Add(new FinanceNews());
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryPattern
{
    class FashionMagazine:Publication
    {
        public override void PublishNews()
        {
            this.PublishedNews.Add(new AdNews());
            this.PublishedNews.Add(new FashionNews());
        }
    }
}

To test it

using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            Publication newsPaper = new NewsPaper();
            Console.WriteLine(newsPaper.GetType().Name);
            foreach (News news in newsPaper.PublishedNews)
            {
                Console.WriteLine("-" + news.GetType().Name);
            }

            Console.WriteLine();

            Publication fashionMagazine = new FashionMagazine();
            Console.WriteLine(fashionMagazine.GetType().Name);
            foreach (News news in fashionMagazine.PublishedNews)
            {
                Console.WriteLine("-" + news.GetType().Name);
            }

            Console.Read();
        }
    }
}

The output

NewsPaper
-AdNews
-FashionNews
-WorldNews
-SportsNews
-FinanceNews

FashionMagazine
-AdNews
-FashionNews