C#

static void Main(string[] args)
{
    string param = "';GO;DROP TABLE Members;--Have a nice day!";
    string sqlCommand = string.Format("select m.member_code,m.Subscriber_code,m.SSN,m.First_name,m.Last_name from member m inner join subscribers s on m.Subscriber_Code=s.Subscriber_Code where m.Subscriber_Code='{0:000000000}'", param);
    Console.WriteLine(sqlCommand);
    Console.ReadKey();
}

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

Richard MacCutchan wrote:

You obviously have no idea what string concatenation means.

Richard MacCutchan wrote:

you obviously do not understand how SQL injection works

Richard Deeming wrote:

And you "obviously do not understand" how a civilized conversation works!

Richard Deeming wrote:

it encourages users to think that string.Format is a good way to build any SQL query, without understanding the details of why your particular query is immune.

Richard MacCutchan wrote:

Sorry, but I did not start this.

Richard MacCutchan wrote:

You obviously have no idea what string concatenation means.

Richard MacCutchan wrote:

It is a single example of how a string.Format statement can be used to create a string when a variable value is to be inserted at a particular point.

if (gridView1[0][2].Value == gridView2[0][2].Value)

public static implicit operator dummy(string value)
{
    return new dummy("????",  value);
}

dummy _foo = new dummy("Json");
_foo.value = "Hello";

Yes, you can do this:

public static implicit operator dummy(string value)
{
    return new dummy("????",  value);
}

And now you have a way to create a new instance of the Class 'dummy with the optional string parameter 'value defined: but, what does that really do for you ? Your intention in designing the code was to require a 'name parameter, and now you have a 'dummy with "????" for a name: is that useful ?

interface IA
{
    void Test();
}

class AImpl : IA
{
    #region IA Members

    public void Test()
    {
    }

    #endregion
}

List<AImpl> lst = new List<AImpl>();

lst.Add(new AImpl());

    IA ib = lst[0];

List<IA> lst2 = new List<IA>(lst);

List<Thingy> source = GetTheListOfThings();
List<IAmTheInterface> result = source.Cast<IAmTheInterface>().ToList();

interface InterfaceA
{
//bunch of methods and properties here
List<InterfaceC> D{get;};
}
interface InterfaceC
{
//bunch of methods and properties here
}
class ClassE : InterfaceA
{
List<InterfaceC> PropertyD
{
get
{
return new List<InterfaceC>(MethodThatReturnsListOfTypeClassF());
}
}
class ClassF : InterfaceC
{
//bunch of properties and methods
}

interface InterfaceA
{
    IReadOnlyList<InterfaceC> D { get; }
}

class ClassE : InterfaceA
{
    public IReadOnlyList<InterfaceC> D
    {
        get { return MethodThatReturnsListOfTypeClassF(); }
    }
}

interface InterfaceA
{
    IEnumerable<InterfaceC> D { get; }
}

class ClassE : InterfaceA
{
    public IEnumerable<InterfaceC> D
    {
        get { return MethodThatReturnsListOfTypeClassF(); }
    }
}

• new List<InterfaceC>(MethodThatReturnsListOfTypeClassF())
• MethodThatReturnsListOfTypeClassF().Cast<InterfaceC>().ToList()
• MethodThatReturnsListOfTypeClassF().ToList<InterfaceC>()

InterfaceA theInstance = GetTheInstanceOfClassE();
theInstance.D.Add(new ClassF());

private List<InterfaceType> listofitems;
public List<InterfaceType> ListOfItems
{
    get {
        if(listofitems==null)
        {
            listofitems=  new List<InterfaceType>(ClassType.GetListOfTypeClassType(this.id));
        }
        return listofitems;
    }
}