15812_file security1

8/3/2019 15812_file security1

http://slidepdf.com/reader/full/15812file-security1 1/32

File creation , writing and reading

class Program

{

static void Main(string[] args)

{

using (StreamWriter sw = new StreamWriter("F:\\TestFile1.txt")) // file

creation

{

// Add some text to the file.

sw.Write("This is the ");

sw.WriteLine("header for the file. is a good boy");sw.WriteLine("-------------------");

// Arbitrary objects can also be written to the file.

sw.Write("The date is: ");

sw.WriteLine(DateTime.Now);

}



using (StreamReader sr = new StreamReader("F:\\TestFile1.doc"))

{

String line;

// Read and display lines from the file until the end of

// the file is reached. while ((line = sr.ReadLine()) != null)

{

Console.WriteLine(line);

}

} }



Appending the text

class Program {


{

string path = @"F:\prac\z3.txt";

// This text is added only once to the file.

if (!File.Exists(path))

{

// Create a file to write to.

using (StreamWriter sw = File.CreateText(path))

{

sw.WriteLine("Hello");

sw.WriteLine("And");

sw.WriteLine("Welcome");

}

}



// This text is always added, making the file longer over time

// if it is not deleted.

using (StreamWriter sw = File.AppendText(path))

{ sw.WriteLine("This");

sw.WriteLine("is Extra");

sw.WriteLine("Text");

}

// Open the file to read from.

using (StreamReader sr = File.OpenText(path))

{

string s = "";

while ((s = sr.ReadLine()) != null)

{ Console.WriteLine(s);

}

}

}



using System.IO;

class Program

{

static void Main()

{ // // Create new folder in C:\ volume. //

Directory.CreateDirectory("C:\\newfolder"); // // Create

another directory with different string literal syntax. //

Directory.CreateDirectory(@"C:\newfolder2"); // // }

R esult of program There are 2 folders on your C:\ drive: 1.

newfolder 2. newfolder2



Directory using System.IO;

namespace dir

{

class Program

{ static void Main(string[] args)

{

if (!Directory.Exists("D:\\Dir1"))

Directory.CreateDirectory("D:\\Dir1");

if (!File.Exists("Dir1\\File1.txt"))

File.Create("Dir1\\File1.txt");

Console.Write("Enter text :: ");

string data = Console.ReadLine(); File.WriteAllText("D:\\Dir1\\File1.txt", data);

string data1 = File.ReadAllText("D:\\Dir1\\File1.txt");

Console.WriteLine(data1);

}

}

}



Write data

namespace ConsoleApplication2

{

class Program

{


{

if (!File.Exists("E:\\test123.txt"))

File.Create("E:\\test123.txt");

string FileName = "E:\\test123.txt";

Console.WriteLine("Adding access control entry for " + FileName);

Console.Read();

// Add the access control entry to the File.

AddFileSecurity(FileName, "ast", FileSystemRights.WriteData,

AccessControlType.Deny);



try

{

using (StreamWriter sw = File.AppendText(FileName)) {

sw.WriteLine("This");

sw.WriteLine("is Extra");

sw.WriteLine("Text");

} }

catch (Exception)

{

Console.WriteLine("trying to attempt write data");

}

}



public static void AddFileSecurity(string FileName, string account,

FileSystemRights rights, AccessControlType controlType)

{

// Get a FileSecurity object that represents the

// current security settings.

FileSecurity fSecurity = File.GetAccessControl(FileName);

// Add the FileSystemAccessRule to the security settings. fSecurity.AddAccessRule(new FileSystemAccessRule(account,

rights, controlType));

// Set the new access settings.

File.SetAccessControl(FileName, fSecurity);

}

} }



File security on read data using System.IO;

using System.Security.AccessControl;

namespace file_secon_read

{

class Program

{ static void Main(string[] args)

{



string FileName = "E:\\test123.txt"; Console.WriteLine("Adding access control entry for "

+ FileName);


AddFileSecurity(FileName, "ast",

FileSystemRights.ReadData, AccessControlType.Deny); }





{




// Add the FileSystemAccessRule to the security settings.

fSecurity.AddAccessRule(new FileSystemAccessRule(account,




}

} }



Add or remove security using System.IO;

using System.Security.AccessControl; namespace ConsoleApplication3

{

class Program

{


{



string FileName = "E:\\test15.txt";

Console.WriteLine("Adding access control entry for "

+ FileName);




AddFileSecurity(FileName, "ast",

FileSystemRights.WriteData, AccessControlType.Deny);

Console.Read();

Console.WriteLine("Removing access control entry from "

+ FileName);

// Remove the access control entry from the File.

RemoveFileSecurity(FileName, "ast", FileSystemRights.WriteData,

AccessControlType.Deny); Console.WriteLine("after remove call");

Console.ReadLine();

}





{




// Add the FileSystemAccessRule to the security settings.

fSecurity.AddAccessRule(new FileSystemAccessRule(account,




}

public static void RemoveFileSecurity(string FileName, string account,


{ // current security settings.




// Remove the FileSystemAccessR ule from the security settings.

fSecurity.RemoveAccessR ule(new FileSystemAccessR ule(account, rights,

controlType));



}

}

}



Generic

Generic allow the programmer to design classes or f unction

member and postpone the definition of types until the class is

instantiated.

Types are open type (it can be any type like int, string , bool)

Reusing of code



Generic

namespace generic

{

class Program

{

static void swap<T>(ref T a, ref T b)

{

T temp;

temp = a; a = b;

b = temp;

}


{

int x=Convert.ToInt16(Console.ReadLine());

int y = Convert.ToInt16(Console.ReadLine());

Console.WriteLine(" val before {0},{1}",x,y);

swap<int>(ref x, ref y);



Console.WriteLine(" val after {0},{1}", x, y);

string m = Console.ReadLine();

string n = Console.ReadLine();

swap<string>(ref m, ref n); Console.WriteLine(" val after {0},{1}", m, n);

}

}

}



Generic delegate

namespace generic1

{

class Program

{


{

m<int, string> m1 = new m<int, string>();

m<int, string>.d d1 = new m<int, string>.d(m1.mymethod); d1(911,"jon");

}

}

class m<T1, T2>

{

public delegate void d(T1 n, T2 m);

public void mymethod(T1 id, T2 name)

{

Console.WriteLine("{0}, {1}", id, name);

}

}



Enumeration

It is a value type used to store a set of named constants such as

days of week, months etc.

Each enumeration has base type that can be one of integral type.

class Program

{ enum Importance

{

None,

Trivial,

Regular, Important,

Critical

};



class Program

{ static void Main()

{ B b1 = B.Dog;

V v1 = V.Hidden;

Console.WriteLine(b1);

Console.WriteLine(v1);

}

enum V { None,

Hidden = 2,

Visible = 4

}; enum B

{ None,

Cat = 1,

Dog = 2

};

}



class Program

{

enum week { sun, mon, tue, wed }; enum season { summer = 1, winter, spring };

enum grades { pass = 65, good = 75, verygood = 85,

distinct = 100 };

static void Main(string[] args) {

int sun1 = (int)week.sun;

int sum=(int)season.spring;

int g = (int)grades.verygood; Console.WriteLine("{0},{1},{2}", sun1, sum, g);

}

}



Overloaded Methods

A type may overload methods, i.e. provide multiple methods with

the same name

Each must have a unique signature and Signature is based u pon

arguments only, the return value is ignored.

void Print(int i);

void Print(string s);

void Print(char c);

void Print(float f);

int Print(float f); // Error: duplicate signature



Operator Overloading

Overloadable binary operators

+ - * / ! ~

% & | ^ == !=

<< >> < > <= >=



Operator Overloading

No overloading for assignment operators, nor

these operators: sizeof, is, as, &&, ||.



Operator Overloading namespace @operator

{ class Program

{


{

Complex num1 = new Complex(2, 3);

Complex num2 = new Complex(3, 4);

Complex sum = num1 + num2;

Console.WriteLine("First complex number: {0}", num1);

Console.WriteLine("Second complex number: {0}", num2);

Console.WriteLine("The sum of the two numbers: {0}", sum);

}

}

class Complex

{

pu blic int real;

pu blic int imaginary;



public Complex(int real, int imaginary)

{ this.real = real;

this.imaginary = imaginary;

}

public static Complex operator +(Complex c1, Complex c2)

{ return new Complex(c1.real + c2.real, c1.imaginary +

c2.imaginary);

}

public override string ToString()

{ return (String.Format("{0} + {1}i", real, imaginary));

}

}

}



is operator

The is operator is used to dynamically test if the r un-time typeof an object is compatible with a given type

public static void Test (object o)

{ if (o is Class1)

{

Console.WriteLine ("o is Class1");

}

else if (o is Class2)

{ Console.WriteLine ("o is Class2");

}



namespace ConsoleApplication94 {

class Program

{


{

Console.WriteLine("{0:C}", 1.2);

Console.WriteLine("{0:C}", -1.2);

Console.WriteLine("{0:D5}", 12);

Console.WriteLine("{0:F3}", 1.2); Console.WriteLine("{0:G}", 1.2);

Console.WriteLine("{0:X}", 123);

}

}

}



Static Constructor

A static constructor is used to initialize any static data, or toperform a particular action that needs performed once only. It is

called automatically before the first instance is created or any

static members are referenced.

A static constructor does not take access modifiers or have

parameters.

public class Bus {

static Bus() {

System.Console.WriteLine("The static constructor invoked."); }

public static void Drive()

{ System.Console.WriteLine("The Drive method invoked."); } } class

TestBus

{static void Main() { Bus.Drive(); } }



Private constructor

pu blic class Counter

{ private Counter()

{

}

pu blic static int currentCount;

pu blic static int IncrementCount()

{ return ++currentCount; }

}

class TestCounter

{ static void Main() { Counter aCounter = new Counter();

Counter.currentCount = 100;

Counter.IncrementCount();

System.Console.WriteLine("New count: {0}", Counter.currentCount); } }



Copy Constructor class Person

{ private string name; private int age;

public Person(Person previousPerson)

{

name = previousPerson.name;

age = previousPerson.age;

}

public Person(string name, int age)

{ this.name = name; this.age = age; }

public string Details

{ get

{ return name + " is " + age.ToString(); } } }

class TestPerson

{ static void Main()

{ // Create a new person object. Person person1 = new Person("George", 40); // Create

another new object, copying person1. Person person2 = new Person(person1);

System.Console.WriteLine(person2.Details); } }

15812_file security1

Documents