Find values in a string

Create a Regex to parse the item: "Name=(.+?);Type=(.+?);Address=(.+?) etc." Then you could create a class to hold all the information

class Record { public string Name; public string Type; public string Address; public string Address2; public string Address3}

then match each line with the regex, fill the fields from Match groups and create an instance of the class and add these to a List<Record> records.

Now you can easily search with linq for:

1. type is HomeUser : records.Where(p=>p.Type=="HomeUser")
2. Address is Germany : records.Where(p=>p.Address=="Germany")
3. Address is Lyon: records.Where(p=>p.Address=="Lyon")

you could easily extend this example to look in all 3 address fields

It would be easier to first define a struct

struct MyStruct
{
    public string Name, Type /* etc.*/ ;
}

After that you'll need to split your input

string[] arrayOfInputs = inpuString.Split(new char[]{Environment.NewLine, '\n', '\r'}) // splits your input, such that every element represents a line
List<MyStruct> myStruct = new List<MyStruct>;
foreach (string s in arrayOfInputs)
{
    string[] arrayOfFields = s.Split(';');
    // arrayOfFields[0] == "Name=name"
    // arrayOfFields[1] == "Type=type"
    // etc. extract needed info
    myStruct.Add(new MyStruct(/* arguments go here */))
}

Now that you have extracted your data and put them into a list of structs, you may search for the required data using Linq

string theNameImLookingFor = from element in myStruct
                             where element.Type == "HomeUser"
                                || element.Address[0] == "Lyon"
                                || element.Address[1] == "Lyon"
                                || element.Address[2] == "Lyon"
                             select element.Name;

string theTypeImLookingFor = from element in myStruct
                             // etc.
                             select element.Type;

Alternatively you can do it like this:

string tNILF = myStruct.Where(element => element.Type == "HomeUser" /* || etc. */).Select(element => element.Name);

One way to do this is to read the key-value pairs into a collection of dynamic objects. Once this is done, you can use the dynamic runtime to query the dynamic objects using LINQ:

To create a collection of dynamic objects:

var users = str.Split("\r\n".ToArray(), StringSplitOptions.RemoveEmptyEntries)
                .Select(x => x.Split(';')
                    .Select(p => p.Split('='))
                    .ToLookup(s => s[0], s => s[1])
                    .ToDictionary(l => l.Key, l => (l.Count() > 1) 
                        ? (object)l.ToList() : (object)l.First())
                    .ToExpando());

Note the use of this extension method:

public static dynamic ToExpando(this IDictionary<string, object> dict)
{
    IDictionary<string, object> expando = new ExpandoObject();
    foreach (var kv in dict)
        expando[kv.Key] = kv.Value;
    return expando;
}

Then you can run the queries you're interested in:

1.Get the names where type is HomeUser:

var homeUsers = users.Where(u => u.Type == "HomeUser")
    .Select(u => u.Name);

2.Get the types where Address =Germany (Note: .Address is a List<string>):

var typesInGermany = users.Where(u=>u.Address.Contains("Germany"))
    .Select(u => u.Type).Distinct();

3.Get the name where address =Lyon:

var namesInLyon = users.Where(u => u.Address.Contains("Lyon"))
    .Select(u => u.Name);