sexta-feira, 16 de outubro de 2009
How to Install Freenx Server on Ubuntu 9.04 Jaunty: 9 steps - wikiHow
1. gksudo gedit /etc/apt/sources.list
2. deb http://ppa.launchpad.net/freenx-team/ppa/ubuntu jaunty main
3. deb-src http://ppa.launchpad.net/freenx-team/ppa/ubuntu jaunty main
4. sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 2a8e3034d018a4ce
Install FreeNX Server
1. sudo apt-get update
2. sudo apt-get install freenx
3. (y)
Configure FreeNX Server
1. sudo /usr/lib/nx/nxsetup --install
2. For server behind a firewall, default key may be okay, (n) for any public system or for greater security, Generate a custom Key Pair (y)
[edit] Tips
* A custom SSH key is recommended for publicly accessible servers
[edit] Things You'll Need
* Ubuntu 9.04 Jaunty
* Internet connection
[edit] Related wikiHows
* How to Update from Ubuntu Warty Warthog to Hoary Hedgehog
* How to Set up a Network in Ubuntu
* How to Burn a CD in Ubuntu Linux
* How to Install Beagle on Ubuntu"
quarta-feira, 7 de outubro de 2009
Restrições em parâmetros de tipo (Guia de programação C#)
Updated: July 2008
When you define a generic class, you can apply restrictions to the kinds of types that client code can use for type arguments when it instantiates your class. If client code tries to instantiate your class by using a type that is not allowed by a constraint, the result is a compile-time error. These restrictions are called constraints. Constraints are specified by using the where contextual keyword. The following table lists the six types of constraints:
Constraint | Description |
---|---|
where T: struct | The type argument must be a value type. Any value type except Nullable can be specified. See Using Nullable Types (C# Programming Guide) for more information. |
where T : class | The type argument must be a reference type; this applies also to any class, interface, delegate, or array type. |
where T : new() | The type argument must have a public parameterless constructor. When used together with other constraints, the new() constraint must be specified last. |
where T : | The type argument must be or derive from the specified base class. |
where T : | The type argument must be or implement the specified interface. Multiple interface constraints can be specified. The constraining interface can also be generic. |
where T : U | The type argument supplied for T must be or derive from the argument supplied for U. This is called a naked type constraint. |
If you want to examine an item in a generic list to determine whether it is valid or to compare it to some other item, the compiler must have some guarantee that the operator or method it has to call will be supported by any type argument that might be specified by client code. This guarantee is obtained by applying one or more constraints to your generic class definition. For example, the base class constraint tells the compiler that only objects of this type or derived from this type will be used as type arguments. Once the compiler has this guarantee, it can allow methods of that type to be called in the generic class. Constraints are applied by using the contextual keyword where. The following code example demonstrates the functionality we can add to the GenericList
public class Employee
{
private string name;
private int id;
public Employee(string s, int i)
{
name = s;
id = i;
}
public string Name
{
get { return name; }
set { name = value; }
}
public int ID
{
get { return id; }
set { id = value; }
}
}
public class GenericListwhere T : Employee
{
private class Node
{
private Node next;
private T data;
public Node(T t)
{
next = null;
data = t;
}
public Node Next
{
get { return next; }
set { next = value; }
}
public T Data
{
get { return data; }
set { data = value; }
}
}
private Node head;
public GenericList() //constructor
{
head = null;
}
public void AddHead(T t)
{
Node n = new Node(t);
n.Next = head;
head = n;
}
public IEnumeratorGetEnumerator()
{
Node current = head;
while (current != null)
{
yield return current.Data;
current = current.Next;
}
}
public T FindFirstOccurrence(string s)
{
Node current = head;
T t = null;
while (current != null)
{
//The constraint enables access to the Name property.
if (current.Data.Name == s)
{
t = current.Data;
break;
}
else
{
current = current.Next;
}
}
return t;
}
}
The constraint enables the generic class to use the Employee.Name property because all items of type T are guaranteed to be either an Employee object or an object that inherits from Employee.
Multiple constraints can be applied to the same type parameter, and the constraints themselves can be generic types, as follows:
class EmployeeListwhere T : Employee, IEmployee, System.IComparable , new()
{
// ...
}
By constraining the type parameter, you increase the number of allowable operations and method calls to those supported by the constraining type and all types in its inheritance hierarchy. Therefore, when you design generic classes or methods, if you will be performing any operation on the generic members beyond simple assignment or calling any methods not supported by System.Object, you will have to apply constraints to the type parameter.
When applying the where T : class constraint, avoid the == and != operators on the type parameter because these operators will test for reference identity only, not for value equality. This is the case even if these operators are overloaded in a type that is used as an argument. The following code illustrates this point; the output is false even though the String class overloads the == operator.
public static void OpTest(T s, T t) where T : class
{
System.Console.WriteLine(s == t);
}
static void Main()
{
string s1 = "foo";
System.Text.StringBuilder sb = new System.Text.StringBuilder("foo");
string s2 = sb.ToString();
OpTest<string>(s1, s2);
}
The reason for this behavior is that, at compile time, the compiler only knows that T is a reference type, and therefore must use the default operators that are valid for all reference types. If you must test for value equality, the recommended way is to also apply the where T : IComparable
You can apply constraints to multiple parameters, and multiple constraints to a single parameter, as shown in the following example:
class Base { }
class Test
where U : struct
where T : Base, new() { }
Type parameters that have no constraints, such as T in public class SampleClass
The != and == operators cannot be used because there is no guarantee that the concrete type argument will support these operators.
They can be converted to and from System.Object or explicitly converted to any interface type.
You can compare to null. If an unbounded parameter is compared to null, the comparison will always return false if the type argument is a value type.
When a generic type parameter is used as a constraint, it is called a naked type constraint. Naked type constraints are useful when a member function with its own type parameter has to constrain that parameter to the type parameter of the containing type, as shown in the following example:
class List
{
void Add(List items) where U : T {/*...*/}
}
In the previous example, T is a naked type constraint in the context of the Add method, and an unbounded type parameter in the context of the List class.
Naked type constraints can also be used in generic class definitions. Note that the naked type constraint must also have been declared within the angle brackets together with any other type parameters:
//naked type constraint
public class SampleClasswhere T : V { }
The usefulness of naked type constraints with generic classes is very limited because the compiler can assume nothing about a naked type constraint except that it derives from System.Object. Use naked type constraints on generic classes in scenarios in which you want to enforce an inheritance relationship between two type parameters.
Date | History | Reason |
---|---|---|
July 2008
| Added paragraph on multiple constraints. | Content bug fix.
|
CodeKeep Snippet : Reflection within a method call. (C#)
Title: | Reflection within a method call. | Language: | C# |
Description: | Calling assembly, current method name, current method's class. | Views: | 326 |
Author: | digitalWraith .net | Date Added: | 5/9/2007 |
Copy | Code | |
1string callingAssemblyName = System.Reflection.Assembly.GetCallingAssembly().FullName; |
CodeProject: Logging method name in .NET. Free source code and programming help
Introduction
Before .NET, we were always looking for a way to log current method name in a log file for better logging. But, there were no functionalities that could have helped in this, and it was left as an uncompleted job.
But, with .NET, we could easily find out the name of the current method or parent method. This has been accomplished by StackFrame
, StackTrace
, and MethodBase
classes in System.Diagnostics
and System.Reflection
namespaces.
StackFrame
provides information about function call on stack call for current process.StackTrace
is a collection ofStackFrame
.MethodBase
is an abstract class containing information about current method.
Note: When an exception occurs in the method, exception object contains a reference to the StackTrace
object that could be used to log the method name. But for logging a method name without an error generated, we need to read it from the stack, using StackFrame
class.
In the sample, MethodBase
object would reference to current function on stack call returned by StackFrame
object. To get the parent method, we would use StackTrace
to get parent�s StackFrame
object.
Create a new console application:
Add namespaces:
using System.Diagnostics;
using System.Reflection;
Create a new static function named WhatsMyName
and call it from the Main
function.
[STAThread]
static void Main(string[] args)
{
WhatsMyName();
}
// function to display its name
private static void WhatsMyName()
{
StackFrame stackFrame = new StackFrame();
MethodBase methodBase = stackFrame.GetMethod();
Console.WriteLine(methodBase.Name ); // Displays �WhatsmyName�
WhoCalledMe();
}
// Function to display parent function
private static void WhoCalledMe()
{
StackTrace stackTrace = new StackTrace();
StackFrame stackFrame = stackTrace.GetFrame(1);
MethodBase methodBase = stackFrame.GetMethod();
// Displays �WhatsmyName�
Console.WriteLine( " Parent Method Name {0} ", methodBase.Name );
}
Note: This feature is not available in .NET Compact Framework as StackFrame
class is unavailable. For that, you would need to use same old method of manually passing method name to the logging function.
License
This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.
A list of licenses authors might use can be found here
terça-feira, 6 de outubro de 2009
[Mono-list] How can I md5 and crypt a string?
[Mono-list] How can I md5 and crypt a string?
Sebastien Pouliot Sebastien PouliotTue, 24 Jun 2003 10:32:08 -0400
- Previous message: [Mono-list] How can I md5 and crypt a string?
- Next message: [Mono-list] Re: mini-doc.txt
- Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
Ariel,
The cryptography in the .NET framework works using byte arrays.
For a similar result, you'll need to convert from string to byte array your
password, hash it, then reconvert the result into a string.
--- Sample ---
using System.Text;
using System.Security.Cryptography;
...
MD5 md = MD5.Create ();
byte[] digest = md.ComputeHash (Encoding.UTF8.GetBytes (password));
string result = Convert.ToBase64String (digest);
---
Sebastien Pouliot
Security Architect, Motus Technologies, http://www.motus.com/
work: spouliot@motus.com
home: spouliot@videotron.ca
----- Original Message -----
From: "Ariel Rios" <jrios@elektra.com.mx>
To: <mono-list@lists.ximian.com>
Sent: Monday, June 23, 2003 7:40 PM
Subject: [Mono-list] How can I md5 and crypt a string?
> In php I can check if a password is correct by doing something like:
> crypt($user_input,$this->getPassword())
>
> Also I can do
> $hash = md5 ($str);
>
> Is there a way to do so currently in mono?
> --
> Ariel Rios <ariel@gnu.org>
> --
> Ariel Rios <jrios@elektra.com.mx>
> Elektra - Gerencia GNU
>
> _______________________________________________
> Mono-list maillist - Mono-list@lists.ximian.com
> http://lists.ximian.com/mailman/listinfo/mono-list
>
- Previous message: [Mono-list] How can I md5 and crypt a string?
- Next message: [Mono-list] Re: mini-doc.txt
- Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]