Design pattern Adapter

Question

i'm learning adapter pattern. I have this code. It's look like this pattern? SQLiteConnection, SQLiteCommand, SQLiteDataReader - it's from other library

Now i have quest: connect and return all users from database. I chose Adapter pattern:

public class user {
    public string _name { get; set; }
    public string _surname { get; set;}

}

public interface IExercise {
    void connectToDataBase();
    void List<user> returnAllUsers();
}

public Adapter : IExercise {
    SQLiteConnection _conn = null;
    SQLiteCommand _cmd;
    public Adapter(SQLiteConnection conn, SQLiteCommand cmd){
        _conn = conn;
        _cmd = cmd;
    }
    public void connectToDataBase(){
        // not important yet
    }

    public List<user> returnAllUsers(){
        _cmd = _conn.newCommand();
        _cmd.CommandText = "SELECT * FROM users";
        SQLiteDataReader dt = _cmd.ExecuteReader();
        List<user> lu = new List<user>();
        while(dt.Read()){
            lu.Add(new user {
                     _name = dt["name"].ToString(),
                     _surname = dt["surname"].ToString()
                    }
                );
        }
        return lu;
    }
}

And my question is only : it's look like Adapter pattern?

Answer 1

I dont understand why do you think your code can look like an Adapter, you doesn't have unmatching interfaces, the Adapter pattern maps the interface of one class onto another so that they can work together. These incompatible classes may come from different libraries or frameworks.

Working example

http://ideone.com/ZZbwAE

Definition

An adapter helps two incompatible interfaces to work together. This is the real world definition for an adapter. The adapter design pattern is used when you want two different classes with incompatible interfaces to work together. Interfaces may be incompatible but the inner functionality should suit the need. The Adapter pattern allows otherwise incompatible classes to work together by converting the interface of one class into an interface expected by the clients.

Example from http://www.dofactory.com/Patterns/PatternAdapter.aspx

using System;

namespace AdapterPattern
{
  /// <summary>
  /// MainApp startup class for Real-World
  /// Adapter Design Pattern.
  /// </summary>
  class MainApp
  {
    /// <summary>
    /// Entry point into console application.
    /// </summary>
    static void Main()
    {
      // Non-adapted chemical compound
      Compound unknown = new Compound("Unknown");
      unknown.Display();

      // Adapted chemical compounds
      Compound water = new RichCompound("Water");
      water.Display();

      Compound benzene = new RichCompound("Benzene");
      benzene.Display();

      Compound ethanol = new RichCompound("Ethanol");
      ethanol.Display();

      // Wait for user
      Console.ReadKey();
    }
  }

  /// <summary>
  /// The 'Target' class
  /// </summary>
  class Compound
  {
    protected string _chemical;
    protected float _boilingPoint;
    protected float _meltingPoint;
    protected double _molecularWeight;
    protected string _molecularFormula;

    // Constructor
    public Compound(string chemical)
    {
      this._chemical = chemical;
    }

    public virtual void Display()
    {
      Console.WriteLine("\nCompound: {0} ------ ", _chemical);
    }
  }

  /// <summary>
  /// The 'Adapter' class
  /// </summary>
  class RichCompound : Compound
  {
    private ChemicalDatabank _bank;

    // Constructor
    public RichCompound(string name)
      : base(name)
    {
    }

    public override void Display()
    {
      // The Adaptee
      _bank = new ChemicalDatabank();

      _boilingPoint = _bank.GetCriticalPoint(_chemical, "B");
      _meltingPoint = _bank.GetCriticalPoint(_chemical, "M");
      _molecularWeight = _bank.GetMolecularWeight(_chemical);
      _molecularFormula = _bank.GetMolecularStructure(_chemical);

      base.Display();
      Console.WriteLine(" Formula: {0}", _molecularFormula);
      Console.WriteLine(" Weight : {0}", _molecularWeight);
      Console.WriteLine(" Melting Pt: {0}", _meltingPoint);
      Console.WriteLine(" Boiling Pt: {0}", _boilingPoint);
    }
  }

  /// <summary>
  /// The 'Adaptee' class
  /// </summary>
  class ChemicalDatabank
  {
    // The databank 'legacy API'
    public float GetCriticalPoint(string compound, string point)
    {
      // Melting Point
      if (point == "M")
      {
        switch (compound.ToLower())
        {
          case "water": return 0.0f;
          case "benzene": return 5.5f;
          case "ethanol": return -114.1f;
          default: return 0f;
        }
      }
      // Boiling Point
      else
      {
        switch (compound.ToLower())
        {
          case "water": return 100.0f;
          case "benzene": return 80.1f;
          case "ethanol": return 78.3f;
          default: return 0f;
        }
      }
    }

    public string GetMolecularStructure(string compound)
    {
      switch (compound.ToLower())
      {
        case "water": return "H20";
        case "benzene": return "C6H6";
        case "ethanol": return "C2H5OH";
        default: return "";
      }
    }

    public double GetMolecularWeight(string compound)
    {
      switch (compound.ToLower())
      {
        case "water": return 18.015;
        case "benzene": return 78.1134;
        case "ethanol": return 46.0688;
        default: return 0d;
      }
    }
  }
}