植入式广告是指将产品或品牌及其代表性的视觉符号甚至服务内容策略性融入电影、电视剧或电视节目各种内容之中，通过场景的再现，让观众在不知不觉中留下对产品及品牌印象，继而达到营销产品的目的。

植入式广告还被称为嵌入式广告或软性广告。植入式广告目前广泛应运用于电影、电视中，冯小刚的贺岁片电影就经常可以看到植入式广告的镜头，例如在主人与赞助商品同时显身时，均会伴随数秒的特写，或者将商品名称台词化、道具化等等。

相对于传统广告形式来说，植入式广告将商品品牌融入娱乐元素中，比较容易取得消费者的认同与好感，改变消费者看广告的逆反心理，在不知不觉之中传播了品 牌的影响力，其效果要优于传统广告形式。不过，植入式广告没有量化的销售和统计方式，实际收效也没有量化的评测指标，也没有权威的工具对广告效果进行评估，因此植入式广告在推广上存在很大的难度，不如传统广告那样易于统计。

开心网目前所探索的植入式广告已经具有相当多的品牌，并且已经融合进了开心网大多数热门游戏之中，从广大用户的使用过程中看，用户并没有对这类广告产生反感，对于一些陌生的品牌，往往或产生一定的好感。

在开心网的热门游戏“买房子、送花园”之中，用户选择打工挣钱的时候，会出现多个“植入式广告”，如下图所示，例如王老吉或W715等，其工资远远高于其他项目，因此容易引起用户的注意，并选择该工作。

选择之后，会出现如下图所示的画面，里面会粗略介绍一下该工作的内容，然后点“详细”后进入厂家的广告页面。

在“买房子”的房价装修上，也会巧妙的融入一些品牌的广告，例如下图中的联想装修套件，类似豪华的装修通常要几十万到数百万元，而这个“联想”品牌的装修仅仅50元，相当于白送，用户购买这个装修后，会在房间的右下角出现联想的品牌广告，巧妙的增加了品牌的曝光度。

在“花园”中，则从多个角度推广“悦活”这个果汁品牌，虽然不少人对于这个品牌是很陌生的，但免费的东西大家都喜欢，在“道具店”中，悦活场景卡是唯一一个可以免费领取和使用的道具卡，使用之后，农场的背景发生变化，并赠送了多个悦活种子。

使用“悦活”的种子具有较高的价格和较快的生长期，5个果实还可以榨汁卖出更多的价钱，而榨出来的果汁送给好友是获得“牧场”的大白母兔幼仔的唯一机会，因此，这个游戏让用户在种地榨汁抽奖的过程中，增加了对“悦活”品牌的好感，从而在间接上增加这种果汁的销量。

在开心网的另一个游戏“争车位”中，道具商店里免费赠送戴尔场景卡，使用这种场景卡后，停车收入会增加到11元每分钟。

使用该场景卡后，停车的背景会被替换为戴尔场景，画面上出现戴尔笔记本的图片，右上角还有戴尔官方网站的链接地址，在潜移默化之中，将整个品牌融入了“争车位”这个游戏之中。

在另一个热门游戏“朋友买卖”之中，安抚奴隶的第一项是请好友吃“必胜客商务套餐”。

很多人选择这个选项的原因，可能仅仅因为使用后，会得到90元的回报，而其他选项的回报金额不会超过这个数字。

以上仅仅是开心网的几个“植入式广告”的例子，实际上，这种广告形式在开心网已经非常普及，这种类型广告在唤起注意或提醒的同时，强化品牌心理，在潜移默化之中争取到消费者的好感，是一种非常完美的网络营销形式，非常值得推广，不过唯一另广告商头疼的是，“植入式广告”的实际效果很难量化评测和统计，通 常只适用于SNS和网页游戏类网站，对于类似月光博客这样的传统内容类型的网站并不适合。

摘自：http://xianguo.com/item/603136655

class Singleton
{
    private static Singleton instance;

    private Singleton()
    {

    }

    public static Singleton GetInstance()
    {
        if (instance == null)
        {
            instance = new Singleton();
        }

        return instance;
    }
}

Client.cs

class Client
{
    static void Main(string[] args)
    {
        Singleton s1 = Singleton.GetInstance();
        Singleton s2 = Singleton.GetInstance();

        if (s1 = s2)
        {
            Console.WriteLine("两个对象是相同的实例");
        }

        Console.Read();
    }
}

单例模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点。

通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其它实例可以被创建，并且它可以提供一个访问该实例的方法。

单例模式因为Singleton类封装它的唯一实例，这样它可以严格地控制客户怎样访问它以及何时访问它。简单地说就是对唯一实例的受控访问。

单例与实用类静态方法的区别：实用类通常也会采用私有化的构造方法来避免其有实例。但与单例还是有区别的。比如实用类不保存状态，仅提供一些静态方法或静态属性以供使用，而单例类是有状态的。实用类不能用于继承多态，而单例虽然实例唯一，却是可以有子类来继承。实用类只不过是一些方法属性的集合，而单例类却是有着唯一的对象实例。

C#与公共语言运行库也提供了一种“静态初始化”方法，这种方法不需要开发人员显式地编写线程安全代码，即可解决多线程环境下它是不安全的问题。代码如下：

SingletonCharp.cs

public sealed class SingletonCharp
{
    private static readonly SingletonCharp instance = new SingletonCharp();
    private SingletonCharp()
    {

    }
    public static SingletonCharp GetInstance()
    {
        return instance;
    }
}

这种静态初始化的方式是在自己被加载时就将自己实例化，所以被形象地称之为饿汉式单例类。

原先的单例模式处理方式是要在第一次被引用时，才会将自己实例化，所以就被称为懒汉式单例类。

注：

• 单例模式的特点：1、单例类只能有一个实例；2、单例类必须自己创建自己的唯一实例；3、单例类必须给所有其它对象提供这一实例。
• 在哪些情况下使用单例模式：1、使用Singleton模式有一个必要条件：在一个系统要求一个类只有一个实例时才应当使用单例模式。反过来，如果一个类可以有几个实例共存，就不要使用单例模式；2、不要使用单例模式存取全局变量。这违背了单例模式的用意，最好放到对应类的静态成员中。3、不要将数据库连接做成单例，因为一个系统可能会与数据库有多个连接，并且在有连接池的情况下，应当尽可能及时释放连接。Singleton模式由于使用静态成员存储类实例，所以可能会造成资源无法及时释放，带来问题。

User.cs

class User
{
    private int _id;
    public int ID
    {
        get { return _id; }
        set { _id = value; }
    }

    private string _name;
    public string NAME
    {
        get { return _name; }
        set { _name = value; }
    }
}

IUser.cs

interface IUser
{
    void Insert(User user);

    User GetUser(int id);
}

SqlserverUser.cs

class SqlserverUser : IUser
{
    public void Insert(User user)
    {
        Console.WriteLine("在SQL Server中给User表增加一条记录。");
    }

    public User GetUser(int id)
    {
        Console.WriteLine("在SQL Server中根据ID得到User表一条记录。");
        return null;
    }
}

AccessUser.cs

class AccessUser : IUser
{
    public void Insert(User user)
    {
        Console.WriteLine("在Access中给User表增加一条记录。");
    }

    public User GetUser(int id)
    {
        Console.WriteLine("在Access中根据ID得到User表一条记录。");
        return null;
    }
}

Department.cs

class Department
{
    private int _id;
    public int ID
    {
        get { return _id; }
        set { _id = value; }
    }

    private string _deptName;
    public string DeptName
    {
        get { return _deptName; }
        set { _deptName = value; }
    }
}

IDepartment.cs

interface IDepartment
{
    void Insert(Department department);

    Department GetDepartment(int id);
}

SqlserverDepartment.cs

class SqlserverDepartment : IDepartment
{
    public void Insert(Department department)
    {
        Console.WriteLine("在SQL Server中给Department表增加一条记录。");
    }

    public Department GetDepartment(int id)
    {
        Console.WriteLine("在SQL Server中根据ID得到Department表一条记录。");
        return null;
    }
}

AccessDepartment.cs

class AccessDepartment : IDepartment
{
    public void Insert(Department department)
    {
        Console.WriteLine("在Access中给Department表增加一条记录。");
    }

    public Department GetDepartment(int id)
    {
        Console.WriteLine("在Access中根据ID得到Department表一条记录。");
        return null;
    }
}

IFactory.cs

interface IFactory
{
    IUser CreateUser();

    IDepartment CreateDepartment();
}

SqlserverFactory.cs

class SqlserverFactory : IFactory
{
    public IUser CreateUser()
    {
        return new SqlserverUser();
    }

    public IDepartment CreateDepartment()
    {
        return new SqlserverDepartment();
    }
}

AccessFactory.cs

class AccessFactory : IFactory
{
    public IUser CreateUser()
    {
        return new AccessUser();
    }

    public IDepartment CreateDepartment()
    {
        return new AccessDepartment();
    }
}

Client.cs

class Client
{
    static void Main(string[] args)
    {
        User user = new User();
        Department department = new Department();

        IFactory factory = new SqlserverFactory();
        //IFactory factory = new AccessFactory();

        IUser iu = factory.CreateUser();
        iu.Insert(user);
        iu.GetUser(1);

        IDepartment id = factory.CreateDepartment();
        id.Insert(department);
        id.GetDepartment(1);

        Console.Read();
    }
}

小结：

• 本例分析：只有一个User类和User操作类时，是只需要工厂模式的，但现在加入新表，而且SQL Server与Access又是两大不同的分类，所以解决这种涉及多个产品系列的问题，用到了抽象工厂模式。
• 优点：最大的好处是易于交换产品系列，由于具体工厂类，如IFactory factory=new AccessFactory()，在一个应用中只需要在初始化时出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置；第二大好处是，它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。
• 缺点：比如我们要增加项目表Project，至少要增加三个类，IProject、SqlserverProject、AccessProject，还需要更改IFactory、SqlserverFactory和AccessFactory才可以完全实现；另外，客户端程序类不只一个时，很多地方都在用IUser或IDepartment，每一个类在开始都会声明IFactory factory=new SqlserverFactory()，如果我有100个调用数据库的类，就要更改100次IFactory factory=new SqlserverFactory()。［此种情况时可以考虑用简单工厂模式＋抽象工厂模式进行，随后也可以再过渡到反射＋抽象工厂模式（反射＋配置文件）］。

简单工厂：

工厂方法：

1、简单工厂模式下，工厂类与具体父类及具体子类都有关联；而工厂模式下，工厂类只与具体父类有关联，由工厂子类负责与具体子类进行关联。

2、如果在简单工厂模式下加入新功能扩展，就要对工厂类做修改，加入新功能；而在工厂模式下，只是单纯地加入工厂子类和具体子类，而不需要对工厂类做修改，做到了“开放扩展，封闭修改”。

3、其实尽管对工厂类不需要做修改了，但是也要对客户端做修改，因为添加了对新功能的调用。也就是说工厂模式做到了对工厂类的开闭原则，却解决不了对客户端的修改。

4、一些情况下，可以考虑用工厂模式＋反射来解决客户端修改问题。

Operation.cs

public class Operation
{
    private double _numberA = 0;
    private double _numberB = 0;

    public double NumberA
    {
        get { return _numberA; }
        set { _numberA = value; }
    }

    public double NumberB
    {
        get { return _numberB; }
        set { _numberB = value; }
    }

    public virtual double GetResult()
    {
        double result = 0;
        return result;
    }
}

OperationAdd.cs

class OperationAdd : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA + NumberB;
        return result;
    }

}

OperationSub.cs

class OperationSub : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA - NumberB;
        return result;
    }
}

OperationMul.cs

class OperationMul : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA * NumberB;
        return result;
    }
}

OperationDiv.cs

class OperationDiv : Operation
{
    public override double GetResult()
    {
        double result = 0;
        if (NumberB == 0)
            throw new Exception("除数不能为0。");
        result = NumberA / NumberB;
        return result;
    }
}

IFactory.cs

interface IFactory
{
    Operation CreateOperation();
}

AddFactory.cs

class AddFactory : IFactory
{
    public Operation CreateOperation()
    {
        return new OperationAdd();
    }
}

SubFactory.cs

class SubFactory : IFactory
{
    public Operation CreateOperation()
    {
        return new OperationSub();
    }
}

MulFactory.cs

class MulFactory : IFactory
{
    public Operation CreateOperation()
    {
        return new OperationMul();
    }
}

DivFactory.cs

class DivFactory : IFactory
{
    public Operation CreateOperation()
    {
        return new OperationDiv();
    }
}

Client.cs

class Client
{
    static void Main(string[] args)
    {
        IFactory operFactory = new AddFactory();
        Operation oper = operFactory.CreateOperation();
        oper.NumberA = 1;
        oper.NumberB = 2;
        double result = oper.GetResult();
        Console.WriteLine(result);
    }
}

小结：

• 模式分析：工厂方法模式是类的创建模式，主要实现的是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。工厂方法模式有一个别名叫多态性工厂模式，因为具体工厂类都有共同的接口或共同的抽象父类。
• 优点：核心的工厂类不再负责所有产品的创建，仅仅负责给出具体工厂必须实现的接口，而不接触哪一个产品类被实例化这种细节，使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。当系统扩展需要添加新的产品对象时，仅仅需要有添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，符合“开放－封闭”原则。

Operation.cs

public class Operation
{
    private double _numberA = 0;
    private double _numberB = 0;

    public double NumberA
    {
        get { return _numberA; }
        set { _numberA = value; }
    }

    public double NumberB
    {
        get { return _numberB; }
        set { _numberB = value; }
    }

    public virtual double GetResult()
    {
        double result = 0;
        return result;
    }
}

OperationAdd.cs

class OperationAdd : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA + NumberB;
        return result;
    }
}

OperationSub.cs

class OperationSub : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA - NumberB;
        return result;
    }
}

OperationMul.cs

class OperationMul : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA * NumberB;
        return result;
    }
}

OperationDiv.cs

class OperationDiv : Operation
{
    public override double GetResult()
    {
        double result = 0;
        if (NumberB == 0)
            throw new Exception("除数不能为0。");
        result = NumberA / NumberB;
        return result;
    }
}

OperationFactory.cs

public class OperationFactory
{
    public static Operation CreateOperate(string operate)
    {
        Operation oper = null;
        switch (operate)
        {
            case "+":
                oper = new OperationAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
        }
        return oper;
    }
}

Client.cs

class Client
{
    static void Main(string[] args)
    {
        Operation oper;
        oper = OperationFactory.CreateOperate("+");
        oper.NumberA = 1;
        oper.NumberB = 2;
        double result = oper.GetResult();
        Console.WriteLine(result);
    }
}

小结：

• 模式分析：简单工厂模式根据提供给它的数据，返回几个类中的一个类的实例。通常返回的类都有一个公共父类和公共方法。
• 优点：工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，通过这种方法实现了对责任的分割。
• 缺点：工厂类集中了所有产品创建逻辑，一旦不能工作，整个系统都要受到影响。同时，系统扩展困难，一旦添加新产品就不得不修改工厂逻辑。

代码对应：

interface IFly
{
    void Fly();
}

interface ILanguage
{
    void Speak();
}

class WideGoose : IFly
{

}

class Penguin : Bird
{
    private Climate climate;
}

class WideGooseAggregate
{
    private WideGoose[] arrayWideGoose;
}

class Bird
{
    private Wing wing;
    public Bird()
    {
        wing = new Wing();
    }
}

abstract class Animal
{
    public Metabolism(Oxygen oxygen,Water water)
    {

    }
}