Same here meld ^^

Dito^^

Hi.

Nach einigem Suchen bin ich auf einen Artikel gestoßen.

Dieser verlinkt einen Blog-Eintrag, in welchem eine Console-Klasse verwendet wird.

Ich hab sie ein bisschen angepasst und werde mich nach Weihnachten mal näher damit beschäftigen.

public class MyConsole : IDisposable
{
	private const UInt32 STD_INPUT_HANDLE = 0xFFFFFFF6;
	private const UInt32 STD_OUTPUT_HANDLE = 0xFFFFFFF5;
	private const UInt32 STD_ERROR_HANDLE = 0xFFFFFFF4;
	private const UInt32 ATTACH_PARENT_PROCESS = 0xFFFFFFFF;
	
	private Int32 m_StdIn;
	private Int32 m_StdOut;
	
	public MyConsole()
	{
		AllocConsole();
		m_StdIn = GetStdHandle(STD_INPUT_HANDLE);
		m_StdOut = GetStdHandle(STD_OUTPUT_HANDLE);
	}
	
	[DllImport("kernel32")]
	private static extern Boolean AttachConsole(UInt32 dwProcessId);
	
	[DllImport("kernel32")]
	private static extern Boolean AllocConsole();
	
	[DllImport("kernel32")]
	private static extern Boolean FreeConsole();
	
	[DllImport("kernel32")]
	private static extern Int32 GetStdHandle(UInt32 nStdHandle);
	
	[DllImport("kernel32")]
	private static extern Boolean WriteConsole(Int32 hConsoleOutput, String lpBuffer, Int32 nNumberOfCharsToWrite, ref Int32 lpNumberOfCharsWritten, Int32 lpReserved);
	
	[DllImport("kernel32")]
	private static extern Boolean ReadConsole(Int32 hConsoleInput, StringBuilder lpBuffer, Int32 nNumberOfCharsToRead, ref Int32 lpNumberOfCharsRead, Int32 lpReserved);
	
	public void WriteLine(String s)
	{
		s += Environment.NewLine;
		Write(s);
	}
	
	public void WriteLine(String format, params Object[] args)
	{
		WriteLine(String.Format(s, args));
	}
	
	public void Write(String format, params Object[] args)
	{
		Write(String.Format(s, args));
	}
	
	public void Write(String s)
	{
		Int32 len = 0;
		WriteConsole(m_StdOut, s, s.Length, ref len, 0);
	}
	
	public String ReadLine()
	{
		Int32 len = 0;
		StringBuilder sb = new StringBuilder();
		ReadConsole(m_StdIn, sb, 256, ref len, 0);
		return sb.ToString(0, sb.Length - 2);
	}
	
	public void Dispose()
	{
		FreeConsole();
	}
}

@herbivore:
Kann man es irgendwie erreichen, dass die Eingabeaufforderung auf das Ende der WinForms-Anwendung wartet?

Gruß, Christian.

Hi, herbivore.

Das ist mir bewusst 😉. Es geht um Win32-Dll's. Ich werd nach Weihnachten mal die Vorschläge von Khalid ausprobieren.

Gruß, Christian.

Hi @ All!

Ich möchte meine Anwendung per StartUpParameter entscheiden lassen, ob sie eine Konsolenanwendung oder eine WinFormsAnwendung ist. Meine Idee: Ich kompiliere als WinFormsAnwendung. Wenn eine Konsole gebraucht wird, dann mit AllocConsole zeigen, in etwa so:

[STAThread]
public static void Main(string[] args)
{
    if (!ConsoleNeeded(args))
    {
        DoSomeWinFormsWork();
    }
    else
    {
        AllocConsole();
        DoSomeConsoleWork();
    }
}

Soweit klar.

Nun hat sich mir die Frage gestellt, was eigtl. der Unterschied ist, wenn man eine Anwendung als WinForms oder als ConsoleApp kompiliert. Ist es nur das angezeigte (bzw. versteckte) Konsolenfenster? Oder passiert da auch mehr?

Gruß, Christian.

Hi, Community.

Ich möchte eine beliebige zur Compilezeit unbekannte Funktion aus einer zur Compilezeit unbekannten Dll in mein Programm einbinden. Für [DllImport(...)] muss die Dll aber eben schon zur Compilezeit bekannt sein. Wie kann ich beliebige Funktionen aus beliebigen Dll's zur Laufzeit einbinden? Muss ich den Umweg über Runtime Compilation und Reflection gehen oder gehts einfacher?

Gruß, Christian.

Danke!

kubi hat Recht!

So muss es aussehen:

#Trigger, der alle Posten mit Anzahl 0 löscht.
CREATE TRIGGER BestelldetailsMinimaleAnzahl AFTER UPDATE ON Bestelldetails
  FOR EACH ROW BEGIN
    IF NEW.Anzahl = 0 THEN #Hier kein "BEGIN"
      DELETE FROM Bestelldetails
      WHERE BestellungID = NEW.BestellungID
      AND ProduktID = NEW.ProduktID
      AND GrößeID = NEW.GrößeID;
    END IF; #Hier "END IF" anstatt nur "END"!
  END;

Hab auch 2x BEGIN, also denke ich doch ja, oder? X(

verwendetes Datenbanksystem: MySQL

Hallo, Community.

Ich brauche in MySQL einen Trigger, der Datensätze löscht, sobald deren Anzahl = 0 ist.
Folgenden Code (der leider nicht funktioniert) habe ich bis jetzt:

#Trigger, der alle Posten mit Anzahl 0 löscht.
CREATE TRIGGER BestelldetailsMinimaleAnzahl AFTER UPDATE ON Bestelldetails
  FOR EACH ROW BEGIN
    IF NEW.Anzahl = 0 THEN BEGIN
      DELETE FROM Bestelldetails 
      WHERE BestellungID = NEW.BestellungID
      AND ProduktID = NEW.ProduktID;
    END;
  END;

Fehlermeldung:

You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '' at line 9

Was ist denn bitte in Zeile 9 falsch? Hab ich was vergessen? Hier finde ich auch nicht, was das Problem sein könnte.

Zur Info die Tabelle Bestelldetails:

#Tabelle Bestelldetails
CREATE TABLE IF NOT EXISTS Bestelldetails (
    BestellungID INT NOT NULL,
    ProduktID INT NOT NULL,
    GrößeID INT NOT NULL,
    Anzahl INT NOT NULL,
    PRIMARY KEY (BestellungID, ProduktID, GrößeID)
);

Gruß, Christian.

        public StatusCodes Status
        {
            get 
            { 
                return Status; // Hier rufst du die Property immer wieder selbst auf...
                // vllt besser return m_Status oder so (also das Feld, wo der Wert gespeichert ist?
            }
            set
            {
                Status = value; // Hier genauso
                StatusChanged(this, new StatusChangeEventArgs(value));
            }
        }

Gruß, Christian.

//Edit: ujr war schneller....

Hi, Danke für eure Antworten!

Ich habe meine Methode nun euren Vorschlägen entsprechend angepasst:

private static String GetPasswordHash(String username, String password)
{
    var hash = MD5.Create();
    var enc = Encoding.Unicode;
    var strToHash = String.Format("{0}::{1}::{2}", enc.GetType().FullName, username.ToLower().Trim(), password);
    var input = enc.GetBytes(strToHash);
    var output = hash.ComputeHash(input);
    var result = Convert.ToBase64String(output);

    return result;
}

So sollte es nun sicher(er) sein, oder?

Gruß, Christian.

Hi!

Ich möchte in meiner DB Anmeldeinformationen speichern. Da ich die Passwörter auf keinen Fall in Klartext speichern kann, habe ich mir eine kleine Methode geschrieben, die diese verschlüsselt. In der DB wird dann nur noch der verschlüsselte String gespeichert. Ist das sicher genug?

private static String GetPasswordHash(String password)
{
    var hash = MD5.Create();

    return Convert.ToBase64String(hash.ComputeHash(Encoding.ASCII.GetBytes(password)));
}

Gruß, Christian.

verwendetes Datenbanksystem: MS SQLServer 2005

Ja, aber es soll sich auch ausblenden und so weiter, ausserdem soll es die ClientArea genau so groß lassen, wie sie ist, es soll die Controls nicht überdecken, etc, pp.

Aber selber bauen wäre ne Lösung 😛
Wollte halt nur wisse, obs so was schon fertig gibt.

Gruß, Chrstian.

Es nennt sich Control Message Bar, das Beispiel ist aber leider in C++ und für Win32. Kennt das vielleicht jemand für .Net?

Hi, Community!

Ich möchte in meiner WinForms-Anwendung gerne so ein "Informationen-Anzeige"-Control wie Firefox es hat benutzen. Ich hatte vor einiger Zeit bei Codeproject auch mal eines gefunden, aber ich habe leider den Namen vergessen. Weiss jemand, wie man so eon Control nennt oder kennt jemand den Artikel bei Codeproject?

Gruß, Christian.

P.S.: Ich meine das Control, mir dem Firefox (hier) fragt, ob man das Passwort speichern möchte.

Hi @ All.

Vor kurzem habe ich Tape.tv entdeckt. Gefällt mir vom Konzept her sehr gut, nur stört mich der Browser und das ganze HTML drum herum. Also würde ich den Flash-Stream (nur den Stream, ohne das ganze HTML drum herum) gerne ein eine Anwendung packen, die diesen abspielt.

Wie sieht das rechtlich aus? Darf ich das? Wenn nein, wie sieht's aus, wenn ich das Programm ausschließlich für mich benutze?

Gruß, Christian.

Stimmt auffallend. 😁

Gruß, Christian.

Habe einen Work-around gefunden, der zu funktionieren scheint:

Statische Klassen sind im IL-Code abstract und sealed!

Aber warum?

.class public abstract auto ansi sealed beforefieldinit AnotherClass ...
.class public auto ansi beforefieldinit MyClass ...

Also:

public void RegisterType(Type type)
{
    if (type.IsClass && type.IsPublic && type.IsAbstract && type.IsSealed)
    {
        foreach (var mi in type.GetMethods(BindingFlags.Public | BindingFlags.Static))
        {
            RegisterMethod(mi);
        }
    }
}

Gruß, Christian.

Hi @ All!

Wie kann man mittels Reflection herausfinden, ob ein Typ statisch ist? Bei Members geht das ja mit BindingFlags. Aber wie bei Typen?

Folgenden Code habe ich bis jetzt:

public class MyClass // Nicht statisch!
{
    public static void FooBar()
    { }
}

public static class AnotherClass // Statisch!
{
    public static void BarBaz()
    { }
}

public class Program
{
    public void RegisterType(Type type)
    {
        if (type.IsClass && type.IsPublic) // && type.IsStatic (gibt es aber leider nicht...)
        {
            foreach (var mi in type.GetMethods(BindingFlags.Public | BindingFlags.Static))
            {
                RegisterMethod(mi);
            }
        }
    }

    public void RegisterMethod(MethodInfo mi)
    {
        //... 
    }

    public static void Main()
    {
        RegisterType(typeof(AnotherClass));
        RegisterType(typeof(MyClass)); // Das soll nicht funktionieren.
        // ...
    }
}

Gruß, Christian.

Hallo, Herbivore.

Genau so hatte ich es gemeint. Aber warum legt der Compiler es nicht einfach fest?

Gruß, Christian.

Gut, Das Beispiel war doof.

public static class ExtensionMethods
{
    public static String GetName(this Object obj)
    {
        return obj.GetType().FullName;
    }
}

public void Foo() {
    MessageBox.Show(GetName()); // Geht nicht
    MessageBox.Show(this.GetName()); // Geht
}

Sinn und Zweck, der dahinter steckt: In Delphi gibt es auch Funktionen, die man ohne Objekt aufrufen kann, wie z.B. ParamStr(...). Das wollte ich mit C# nachbilden, ohne eine Helper-Klasse mit statischen Methoden machen zu müssen.

Extensionmethods sind Methodenerweiterungen für Typen. Ohne Typ keine Erweiteurng (s.u.).

Aber mit oder ohne this ist doch eigtl egal, weil doch, wenn man das this weglässt, immer eine Methode in der eigenen Klasse gemeint ist, oder nicht?
// Edit: Nein. Es können auch Basis-Klassen gemeint sein. Ergo --> Der Compiler weis nicht, nach welcher Extension-Method er suchen soll, ob von der Aktuellen, oder von einer Basisklasse.

Gruß, Christian.

Hi @ All!

Folgender Code:

public static class ExtensionMethods
{
    public static void Run(this Object obj, ThreadStart start)
    {
        new Thread(start).Start();
    }

    public static void Run(this Object obj, ParameterizedThreadStart start, Object arg)
    {
        new Thread(start).Start(arg);
    }
}

public void Foo() {
    Run(Bar); // Funktioniert nicht --> Der Name "Run" ist im aktuellen Kontext nicht vorhanden.
    this.Run(Bar);
}

public void Bar() {
    // Werkel, Werkel...
}

Warum funktioniert die Extension Methode mit this, ohne aber nicht?

Gruß, Christian.

Hi.

Das mit Java stimmt nicht ganz.

Man muss die Exception abfangen oder weiterleiten.

so in etwa:

public void DoSomething() throws Exception { 
    throw new Exception();
}

public void DoSomethingElse1() throws Exception {
    DoSomething(); // Kann man jetzt benutzen, weil die Exception weitergeleitet wird
}

public void DoSomthingElse2() {
    try {
        DoSomething(); // Funktioniert auch, Exception wurde abgefangen
    }
    catch {}
}

public void DoSomethingElse3() {
    DoSomething(); // Compilerfehler, Exception wird ignoriert
}

Gruß, Christian.

Hi, probierts mal so:

private void ReadThread(object Parameter)
{
    Process _process = (Process)Parameter;
    StreamReader oReader2 = _process.StandardOutput;
    StringBuilder sb = new StringBuilder();
    while(!_process.HasExited)
    {
        sb.Append((char)oReader2.Read());
    }
    MessageBox.Show(sb.ToString();
}

oder so:

private void ReadThread(object Parameter)
{
    Process _process = (Process)Parameter;
    StreamReader oReader2 = _process.StandardOutput;
    MessageBox.Show(oReader2.ReadToEnd());
}

Gruß, Christian.

probiers mal so:

copy "C:\Program Files\Microsoft Visual Studio 8\VC#\CSharpProjects\date_string\date_string\bin\Release\date_string.exe" c:\temp
set AGCLOG="C:\RCP VIEWER PARSER\report.txt"
echo Setting the variable...
echo --- start --------------------------------------------------------------------- >> %AGCLOG%
C:\temp\date_string.exe >> %AGCLOG%
pause

Gruß, Christian.

Danke, Reflector war ne gute Idee.

SetLength benutzt die SetEndOfFile-Funktion in der Kernel32.dll.

MSDN sagt dazu:

Sets the physical file size for the specified file to the current position of the file pointer.

Gruß, Christian.

Hi, Community.

Ich habe einen FileStream, der auf eine von mir oft benutze Datei zeigt. Nun habe mich gefragt, ob SetLength() auch die Länge der Datei beeinflusst oder nur die des Streams.

Gruß, Christian.

Nur eine Vermutung: Hast du das richtige DirectX installiert?

Gruß, Christian.

Hi, Golo.

unter .NET 2.0 könntest du einen statische Klasse StringEx mit der entsprechenden Methode machen. Die Aufruf-Syntax ist dann nicht so schön, wie bei Extension Methods. Aber inhaltlich läuft es auf das gleiche hinaus.

Unter .Net 2.0 funktionieren Extension Methods mit einem kleinen Trick auch (VS 2008 vorausgesetzt):

Einfach folgenden Code ins Projekt hinzufügen.

namespace System.Runtime.CompilerServices
{
  [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
  public class ExtensionAttribute : Attribute
  {
  }
}

Gruß, Christian.

Hi, Atomroflman.

Du musst dir eine BerufeCollection-Klasse erstellen, da kannst du dann einen Indexer einbauen.

class BerufeCollection: ICollection<Beruf>
{
    public Beruf this[String index]
    {
        get
        { // Wert holen
        }
        set
        { // Wert setzen
        }
    }

    // Implementierung von ICollectioin
}

Gruß, Christian.

@onlinegurke:

Wieder was dazugelernt. Wie schon sehr oft festgestellt:

Programmieren ist die einfachste Sache der Welt, wenn man die Klassen kennt, die das, was man grade programmiert, schon fertig implementiert haben....

TypeDescriptor.GetConverter() kannte ich noch nicht, und natürlich ist diese Methode meiner vorzuziehen, da x-mal getestet, viel benutzt und deswegen besser.

Gruß, Christian

Beschreibung:

Main-Thread hier!

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Text.RegularExpressions;

namespace ExtensionLibrary
{
    public static class IEnumerableExtensionMethods
    {
        // Extensions Methods
        #region +^ Implode<T>(this IEnumerable<T> enumerable, Int32 start, Int32 end, String separator)

        /// <summary>
        /// Implodes the <paramref name="enumerable"/> to a string containing the string representants of each item, seperated by <paramref name="seperator"/>.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="enumerable">The enumerable.</param>
        /// <param name="start">The start index.</param>
        /// <param name="end">The end index.</param>
        /// <param name="separator">The separator.</param>
        /// <returns></returns>
        public static String Implode<T>(this IEnumerable<T> enumerable, Int32 start, Int32 end, String separator)
        {
            StringBuilder sb = new StringBuilder();

            for (Int32 i = start; i < end; i++)
            {
                sb.Append(enumerable.ElementAt(i));
                if (i < end - 1)
                {
                    sb.Append(separator);
                }
            }

            return sb.ToString();
        }

        #endregion
        #region +^ Implode<T>(this IEnumerable<T> enumerable, String separator)

        /// <summary>
        /// Implodes the <paramref name="enumerable"/> to a string containing the string representants of each item, seperated by <paramref name="seperator"/>.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="enumerable">The enumerable.</param>
        /// <param name="separator">The separator.</param>
        /// <returns></returns>
        public static String Implode<T>(this IEnumerable<T> enumerable, String separator)
        {
            return Implode(enumerable, 0, enumerable.Count(), separator);
        }

        #endregion
        #region +^ ImplodeFormatted<T>(this IEnumerable<T> enumerable, Int32 start, Int32 end, String format)

        /// <summary>
        /// Implodes the <paramref name="enumerable"/> to a string containing the formatted string representants of each item.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="enumerable">The enumerable.</param>
        /// <param name="start">The start index.</param>
        /// <param name="end">The end index.</param>
        /// <param name="seperatorFormat">The seperator format.</param>
        /// <returns></returns>
        public static String ImplodeFormatted<T>(this IEnumerable<T> enumerable, Int32 start, Int32 end, String seperatorFormat)
        {
            StringBuilder sb = new StringBuilder();

            for (Int32 i = start; i < end; i++)
            {
                sb.AppendFormat(seperatorFormat, enumerable.ElementAt(i));
            }

            return sb.ToString();
        }

        #endregion
        #region +^ ImplodeFormatted<T>(this IEnumerable<T> list, String format)

        /// <summary>
        /// Implodes the <paramref name="enumerable"/> to a string containing the formatted string representants of each item.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="enumerable">The enumerable.</param>
        /// <param name="format">The format.</param>
        /// <returns></returns>
        public static String ImplodeFormatted<T>(this IEnumerable<T> enumerable, String format)
        {
            StringBuilder sb = new StringBuilder();

            foreach (T item in enumerable)
            {
                sb.AppendFormat(format, item);
            }

            return sb.ToString();
        }

        #endregion
    }
}

Implode und die verschiedenen Überladungen bewirken Folgendes:

var ints = new List<Int32>(new Int32[] { 12, 13, 14, 15 });

Console.WriteLine(ints.Implode(", "));
// Ausgabe:
// "12, 13, 14, 15"

Console.WriteLine(ints.ImplodeFormattet("Nummer {0}, "));
// Ausgabe:
// "Nummer 12, Nummer 13, Nummer 14, Nummer 15"

Gruß, Christian.

Schlagwörter: Extension Methods Extensionmethods Sammlung IEnumerable

Beschreibung:

Main-Thread hier!

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Text.RegularExpressions;

namespace ExtensionLibrary
{
    public static class ReflectionExtensionMethods
    {
        // Extensions Methods
        #region +^ GetCustomAttribute<T>(this MemberInfo info)

        /// <summary>
        /// Gets the custom attribute associated to the passed MemberInfo.
        /// </summary>
        /// <typeparam name="T">The attribute type.</typeparam>
        /// <param name="info">The info.</param>
        /// <returns></returns>
        public static T GetCustomAttribute<T>(this MemberInfo info) where T : Attribute
        {
            return (T) Attribute.GetCustomAttribute(info, typeof(T));
        }

        #endregion
        #region +^ IsAttributeDefined<T>(this MemberInfo info)

        /// <summary>
        /// Determines whether the attribute is defined in the specified MemberInfo.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="info">The MemberInfo.</param>
        /// <returns>
        /// 	<c>true</c> if the attribute is defined in the specified MemberInfo; otherwise, <c>false</c>.
        /// </returns>
        public static Boolean IsAttributeDefined<T>(this MemberInfo info) where T : Attribute
        {
            return Attribute.IsDefined(info, typeof(T));
        }

        #endregion
        #region +^ InvokeStatic(this MethodInfo info, params Object[] parameters)

        /// <summary>
        /// Invokes <paramref name="info"/> if it is static, passing the <paramref name="parameters"/>.
        /// </summary>
        /// <param name="info">The info.</param>
        /// <param name="parameters">The parameters.</param>
        /// <exception cref="ArgumentException" />
        /// <returns></returns>
        public static Object InvokeStatic(this MethodInfo info, params Object[] parameters)
        {
            if (!info.IsStatic)
            {
                throw new ArgumentException("The method is not static!", "info");
            }
            return info.Invoke(null, parameters);
        }

        #endregion
        #region +^ InvokeStaticReturn<T>(this MethodInfo info, params Object[] parameters)

        /// <summary>
        /// Invokes <paramref name="info"/> if it is static, passing the <paramref name="parameters"/> and returns <typeparamref name="T"/>.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="info">The info.</param>
        /// <param name="parameters">The parameters.</param>
        /// <exception cref="ArgumentException" />
        /// <returns></returns>
        public static T InvokeStaticReturn<T>(this MethodInfo info, params Object[] parameters)
        {
            if (!info.IsStatic)
            {
                throw new ArgumentException("The method is not static!", "info");
            }
            return (T) info.Invoke(null, parameters);
        }

        #endregion
        #region +^ GetPropertyValue<T>(this Object value, String propertyName, Object[] indexes)

        /// <summary>
        /// Gets the value of the property with specified name.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value">The value.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <param name="indexes">The indexes.</param>
        /// <returns></returns>
        public static T GetPropertyValue<T>(this Object value, String propertyName, Object[] indexes)
        {
            return (T) GetPropertyValue(value, propertyName, indexes);
        }

        #endregion
        #region +^ GetPropertyValue<T>(this Object value, String propertyName, Object[] indexes)

        /// <summary>
        /// Gets the value of the property with specified name.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value">The value.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <returns></returns>
        public static T GetPropertyValue<T>(this Object value, String propertyName)
        {
            return (T) GetPropertyValue(value, propertyName, null);
        }

        #endregion
        #region +^ GetPropertyValue(this Object value, String propertyName)

        /// <summary>
        /// Gets the value of the property with specified name.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <returns></returns>
        public static Object GetPropertyValue(this Object value, String propertyName)
        {
            return GetPropertyValue(value, propertyName, null);
        }

        #endregion
        #region +^ GetPropertyValue(this Object value, String propertyName, Object[] indexes)

        /// <summary>
        /// Gets the value of the property with specified name at the specified indexes.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <param name="indexes">The indexes.</param>
        /// <returns></returns>
        public static Object GetPropertyValue(this Object value, String propertyName, Object[] indexes)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            if (String.IsNullOrEmpty(propertyName))
            {
                throw new ArgumentNullException("propertyName");
            }

            PropertyInfo property = value.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

            if (property == null)
            {
                throw new Exception("The property does not exist for the target object.");
            }
            if (!property.CanRead)
            {
                throw new Exception("The property cannot be read.");
            }

            return property.GetValue(value, indexes);
        }

        #endregion
    }
}

Gruß, Christian.

Schlagwörter: Extension Methods Extensionmethods Sammlung Reflection MethodInfo MemberInfo Attribute

Beschreibung:

Main-Thread hier!

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Text.RegularExpressions;

namespace ExtensionLibrary
{
    public static class StringExtensionMethods
    {
        // Extensions Methods
        #region +^ IsNullOrEmpty(this String s)

        /// <summary>
        /// Determines whether the specified string is null or empty.
        /// </summary>
        /// <param name="s">The string.</param>
        /// <returns>
        /// 	<c>true</c> if the string is null or empty; otherwise, <c>false</c>.
        /// </returns>
        public static Boolean IsNullOrEmpty(this String s)
        {
            return s == null || s.Trim().Length == 0;
        }

        #endregion
        #region +^ To<T>(this String s, IFormatProvider provider)

        /// <summary>
        /// Converts the specified string to <typeparamref name="T"/>.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="s">The string.</param>
        /// <param name="provider">The provider.</param>
        /// <returns></returns>
        public static T To<T>(this String s, IFormatProvider provider)
        {
            return (T) Convert.ChangeType(s, typeof(T), provider);
        }

        #endregion
        #region +^ To<T>(this String s)

        /// <summary>
        /// Converts the specified string to <typeparamref name="T"/>.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="s">The string.</param>
        /// <returns></returns>
        public static T To<T>(this String s)
        {
            return (T) Convert.ChangeType(s, typeof(T));
        }

        #endregion
        #region +^ IsValid(this String s, String regex)

        /// <summary>
        /// Determines whether the specified string matches the specified Regex.
        /// </summary>
        /// <param name="s">The string.</param>
        /// <param name="regex">The regex.</param>
        /// <returns>
        /// 	<c>true</c> if the specified s is valid; otherwise, <c>false</c>.
        /// </returns>
        public static Boolean IsMatch(this String s, String regex)
        {
            return new Regex(regex).IsMatch(s);
        }

        #endregion
    }
}

IsNullOrEmpty und IsMatch sind denke ich selbsterklärend.

Die To<T>()-Methode ist eigentlich nur eine Kurzform von Convert.ChangeType():

var myStr = "12";
var myInt = myStr.To<Int32>();

myStr = "12,32";
var myDouble = myStr.To<Double>();

Gruß, Christian.

Schlagwörter: Extension Methods Extensionmethods Sammlung String

@JunkyXL:

Da hast du natürlich recht, siehe hier. Aber mit String.IsNullOrEmpty() wäre es nur gleichwertig, wenn das Trim() nicht dabei wäre!

@xxxprod:

Die GetReflected(), SetReflected() und GetProperty() Methoden kann ich sehr gut gebrauchen. Gute Idee, Gute Umsetzung! Danke!
Zum Thema einzeln posten: Kann ich nachvollziehen, aber für jede ExtensionMethod einen eigenen Thread zu erstellen finde ich erstens zu viele Threads und zweitens unübersichtlich, wenn man alle durchsehen möchte. Und eine (zwar kurze) Beschreibung ist ja auch in den XML-Kommentaren drin.

Gruß, Christian.

Beschreibung:

Ich bin immer auf der Suche nach hilfreichen Extension-Methods. Aber da man nicht allzuviele (bzw. immer wieder die gleichen) über Google und Co findet, hab ich mir gedacht, man könnte hier eine kleine Sammlung von Extension Methods aufmachen, zu der jeder gute und hilfreiche Extensionmethods hinzufügen kann.

Weitere Threads mit Extension Methods:
String
Reflection
IEnumerable

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Text.RegularExpressions;

namespace ExtensionLibrary
{
    public static class VariousExtensionMethods
    {
        // Extensions Methods
        #region +^ GetTypeConverter(this Type type)

        /// <summary>
        /// Gets the type converter bound to the passed type.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <returns></returns>
        public static TypeConverter GetTypeConverter(this Type type)
        {
            if (type.IsAttributeDefined<TypeConverterAttribute>())
            {
                return (TypeConverter) Activator.CreateInstance(Type.GetType (type.GetCustomAttribute<TypeConverterAttribute> ().ConverterTypeName));
            }
            return null;
        }

        #endregion
        #region +^ SerializeToStream(this Object obj, Stream stream)

        /// <summary>
        /// Serializes the specified object to the specified stream.
        /// </summary>
        /// <param name="obj">The object.</param>
        /// <param name="stream">The stream.</param>
        public static void SerializeToStream(this Object obj, Stream stream)
        {
            new BinaryFormatter().Serialize(stream, obj);
            stream.Position = 0;
        }

        #endregion
    }
}

Ich hoffe, es werden sich viele beteiligen, damit die Sammlung auch einen guten Umfang bekommt.

Gruß, Christian.

EDIT
Auf Bitte von herbivore verscheidene Threads mit verschiedenen ExtensionMethodsGruppen

Schlagwörter: Extension Methods Extensionmethods Sammlung

Hi, Community!

Ist euch mal aufgefallen, das die Extensionmethods Sachen erlauben, die mit "normalen" Methoden nicht funktionieren?

z.B. das hier:

public class Program
{
    public static void Main()
    {
        if (((String) null).IsNullOrEmpty())
        {
            MessageBox.Show("Test");
        }
    }
}

public static class ExtensionMethods
{
    public static Boolean IsNullOrEmpty(this String s)
    {
        return s == null || s.Trim().Length == 0;
    }
}

Als erstes dachte ich mir, da müsste doch eingentlich eine NullReferenceException kommen, aber dann habe ich mir mal angeschaut, wie der Compiler diese überhaupt umsetzt:

public class Program
{
    public static void Main()
    {
        if (ExtensionMethods.IsNullOrEmpty(null))
        {
            MessageBox.Show("Test");
        }
    }
}

Das müsste von Seiten des Compilers imho abgestellt werden, denn ich finde, das verwirrt nur und trägt nicht zur Funktionalität bei.
Wie seht ihr das?

Gruß, Christian.

Das ist aber sehr Quick'n'Dirty. da würd ich meine Lösung bevorzugen.

Hi, Herbivore und Hiiims.

Herbivore hat natürlich wieder Recht. 😁

Aber da mich das auch interessiert hab ich mich mal rangesetzt, ein bisschen gegoogelt und schließlich bei CodeProject eine Lösung gefunden.

GlobalKeyboardHook hook = new GlobalKeyboardHook();

public Form1()
{
    InitializeComponent();
    hook.HookedKeys.Add(Keys.LShiftKey);
    hook.KeyDown += new KeyEventHandler(hook_KeyDown);
    hook.KeyUp += new KeyEventHandler(hook_KeyUp);
}

private void hook_KeyUp(object sender, KeyEventArgs e)
{
    MessageBox.Show("Up\t" + e.KeyCode.ToString());
    e.Handled = true;
}

private void hook_KeyDown(object sender, KeyEventArgs e)
{
    MessageBox.Show("Down\t" + e.KeyCode.ToString());
    e.Handled = true;
}

Die Klasse GlobalKeyboardHook findet ihr im Anhang.

Hi, Hiiims.

Eigentlich müsste Keys.LShiftKey funktionieren.

Zeig mal deinen ganzen Code in Form1_KeyDown, vllt ist da was falsch.

Gruß, Christian.

Das wusste ich noch nicht =). Danke für den Hinweis 👍.

Gruß, Christian.

Hi, Peter.

Der Link hat mir gut geholfen und jetzt funktioniert auch alles so wie es soll.

Aber warum ist Request.QueryString["key"] besser als Request["key"]?

Gruß, Christian.

Hi Community!

Ich beschäftige mich seit kurzem mit Asp.Net.

Habe ein UserControl, auf dem eine Textbox sitzt, in die man Daten eingibt, nach denen dann in der Datenbank gesucht wird. Hat man allerdings einmal was in die Textbox eingegeben, kann man den Inhalt der Textbox nicht mehr ändern?!

Hier ein bisschen Code:

<%@ Control Language="C#" AutoEventWireup="true" CodeFile="Search.ascx.cs" Inherits="Controls.Search" %>
<center>
    <h1>
        Suche</h1>
    <br />
    <asp:TextBox ID="tbxSearch" runat="server" Width="300px" />&nbsp;&nbsp;
    <asp:Button ID="btnSearch" runat="server" Text="Suchen!" OnClick="btnSearch_Click" /><br />
    <br />
    <asp:Label ID="lblResult" runat="server" Text="Result" Visible="false" />
</center>

        protected void Page_Load(object sender, EventArgs e)
        {
            if (!String.IsNullOrEmpty(Request["mode"]))
            {
                var mode = Request["mode"].ToLower();
                tbxSearch.Text = Request["search"];

                if (mode == "view")
                {
                    // Hier eine SQL-Abfrage nach den Details eines ausgewählten Datensatzes - Funktioniert einwandfrei
                }
                else if (mode == "search")
                {
                    //Hier die Such-SQL-Abfrage - Funktioniert auch einwandfrei.
                }
            }
        }

        protected void btnSearch_Click(object sender, EventArgs e)
        {
            // Hier ist tbxSearch.Text immer das, was ich zuerst eingegeben habe und nicht das, was ich grade eingegeben habe!
            Response.Redirect(String.Format("http://lh/dnn/Default.aspx?TabId={0}&mode=search&search={1}", TabId, tbxSearch.Text));
        }

Hat jemand eine Idee, warum ich nach dem ersten Klick auf btnSuchen den Inhalt der Textbox nicht mehr ändern kann?

Gruß, Christian.

Nur eine Vermutung: Ist zu diesem Zeitpunkt das .Net Framework schon geladen?

Danke, so gehts. 👍

Hi, Community!

Da ich mich schon länger mit DotNetNuke beschäftige, habe ich mal damit angefangen, eine eigene WebAnwendung, die von DNN "gehostet" wird, zu schreiben.
Also hab ich ein neues Asp.Net Usercontrol erstellt (Sucht in einer Datenbank nach vom User eingegebenen Daten und zeigt eine kleine Übersicht), das von PortalModuleBase erbt, darin ein bisschen Logik eingebaut und dann die zugehörige Moduldefinition in DNN erstellt. Funktioniert alles prima (Datenbankanbindung mit LinqToSql ist ne tolle Sache 😄), konnte das Modul auch einwandfrei verwenden.
Jetzt hab ich mir gedacht, ich mache mir zum Ansehen der Details ein eigenes Modul. Also hab ich das Modul programmiert, funktioniert auch einwandfrei.

Aber jetzt zu meinem Problem: Wie bekomme ich die ID des Datensatzes vom "Suchen"-Modul ins "Anzeigen"-Modul (sind beide auf der selben Seite)?

Gruß, Christian.

Am besten ist es imho, du packst das ganze in eine picturebox und zeichnest auf das image.

Gruß, Christian.

Hallo Rahvin,

Zumindest Process Explorer muss eine Möglichkeit kennen. Wenn man sich die Eigenschaften eines Prozesses anguckt, werden auch alle zugehörigen Threads angezeigt.

Gruß, Christian.

Oder du nimmst anstatt der TextBox in die die kommandos eingegeben werden einfach ne combobox, in der alle Befehle in den Items drin sind..

Gruß, Christian.

Gutes Spiel!

Würde ich vllt auch kaufen, wenns auf dem Markt wäre!

Aber ein paar kleine Verbesserungsvorschläge habe ich^^:
1.Die Kommandos sollten nicht CaseSensitive sein (oder ist das Absicht?). 1.Auf Rechtschreibfehler in der Ausgabe achten, damit es realistischer wirkt. 1.Du könntest das Programm obfuscaten, damit man nicht einfach in den Quellcode gucken kann (Reflector sei dank). Dann wäre es noch schwerer, das Programm zu hacken^^ (es sei denn, du willst, dass der "Hacker" diese Möglichkeit hat) 1.Zum Remotedesktop: Ich an deiner stelle würde nicht Pictureboxen verwenden. (Eventuell kann das helfen?!: [Tutorial] Zeichnen in Windows-Programmen (Paint/OnPaint, PictureBox))

Ansonsten: Sehr gute Idee, gelungene Umsetzung!

Gruß, Christian.

Ich kann da nur XSL empfehlen.

Gruß, Christian