Thunderstruck is a .NET library that simplifies and speeds up access to databases using ADO.NET without being an ORM. It provides a DataContext object that handles connections, transactions, and commands. DataObjects like DataObjectCommand and DataObjectQuery further abstract common database operations like insert, update, delete, and select using parameters binding. Custom DataObjects can be used for non-standard table and field names.

1. Thunderstruck
A really fast way to access databases

2. What?
Thunderstruck is a .NET library that makes
access to databases more simple and fast
using ADO.NET.

3. Another ORM?
No! Thunderstruck don't is a ORM.
It don't abstracts the powerful database,
just makes easy the access, really!

4. How?
Thunderstruck

5. How?
First, set your connection string.

6. How?
<connectionStrings>
<add name="Default" (...)
</connectionStrings>

7. How?
Now, you need meeting a important object
called DataContext. It controls every
connection, transaction and command to the
database.

8. How?
using (var context = new DataContext())
{
context.Execute("DELETE FROM Cars");
context.Execute("DELETE FROM Tools");
context.Commit();
}

9. How?
Caution!
It will clean your garage :)

10. How?
Yes!
Forget connection string, open connection,
close connection, create command, execute
command... DataContext does it for you!

11. Transactional
DataContext controls the connection, and it's
transactional by default, nothing was made
before the commit.

12. How does not Transactional?
using (var context = new DataContext(Transaction.No))
{
context.Execute("DELETE FROM Cars");
context.Execute("DELETE FROM Tools");
}

13. Connection String
Maybe you want to use another specified
connection string for a different database.

14. Connection String
using (var context = new DataContext("OtherDatabase"))
{
context.Execute("DELETE FROM Cars");
context.Execute("DELETE FROM Tools");
context.Commit();
}

15. And Queries?
Is easy to get a value on database!

16. DataContext.GetValue
var query = "SELECT COUNT(Id) FROM Tools";
var toolsCount = context.GetValue(query);

17. And Queries?
Or get a list of objects on database...

18. DataContext.All
var allCars = context.All<Car>("SELECT * FROM Cars");

19. DataContext
This is the basic uses of DataContext...
really simple and fast!

20. DataContext Methods
Thunderstruck

21. DataContext Methods
● Execute -- Executes a database sql
command and returns the number of rows
affected.
● ExecuteGetIdentity -- Executes a sql
command and returns the last identity value
inserted.

22. DataContext Methods
● GetValue -- Executes a sql query and
returns the value of first column of the first
row.
● GetValue<Type> -- Same as GetValue, but
makes a Convert to specified type.
● GetValues<Type> -- Executes a sql query
and returns list of values of first column in
the specified type.

23. DataContext Methods
● First<Type> -- Executes a sql query and
return the first result binded in specified
object.
● All<Type> -- Same as first, but returns a list
of all rows.

24. Parameters Binding
Thunderstruck

25. Parameters Binding
Thunderstruck is focused on use of sql, and
this involves parameters... many parameters.

26. Parameters Binding
Concatenate sql parameters will
take you to hell!

27. Parameters Binding
"INSERT INTO Car VALUES ('"+ carName +"', "+ modelYear
+")"

28. Parameters Binding
Ugly and insecure, really!
Thunderstruck makes it easy...

29. Parameters Binding (on Sql Server)
var command = "INSERT INTO Car VALUES (@Name,
@ModelYear)";
context.Execute(command, car);

30. Parameters Binding
Thunderstruck will bind the car properties with
the query parameters.

31. Future cars
var query = "SELECT * FROM Car WHERE ModelYear > @Year";
car futureCars = context.All<Car>(query, DateTime.Today);

32. DataObjects
Thunderstruck

33. DataObjects
Manipulate sql is powerful, but repetitive.

34. DataObjects
DataObjects abstracts more commons
database operations:
INSERT, UPDATE, DELETE and SELECT.

35. DataObjects
Thats operations are separated in two objects:
DataObjectCommand and DataObjectQuery.

36. DataObjects
Assuming that this class
exists in the domain...

37. DataObjects
class Car
{
public int Id { get; set; }
public string Name { get; set; }
public int ModelYear { get; set; }
}

38. DataObjects
In this are created two objects (DataObjects)
to manipulate cars on database...

39. DataObjects
var command = new DataObjectCommand<Car>();
var select = new DataObjectQuery<Car>();

40. DataObjects
Or, more pretty, put this (separated)
in properties...

41. DataObjects
public DataObjectCommand<Car> Command
{
get { return new DataObjectCommand<Car>(); }
}
public DataObjectQuery<Car> Select
{
get { return new DataObjectQuery<Car>(); }
}

42. DataObjects
Ok, done. Just use.

43. DataObjectCommand
Thunderstruck

44. DataObjectCommand Insert
Command.Insert(car);

45. DataObjectCommand Insert
It will bind the generated primary key.

46. DataObjectCommand Insert
// car.Id == 0
Command.Insert(car);
// car.Id > 0

47. Transactional DataObjectCommand
In this case, DataObjectCommand creates an
internal DataContext, but in transactional
procedures you can specify it.

48. Transactional DataObjectCommand
Command.Insert(car, context);
(...)
context.Commit();

49. Transactional DataObjectCommand
Update and Delete has the same
transactional behavior.

50. DataObjectCommand
car.Name = "Lotus Esprit";
Command.Update(car);
Command.Delete(car);

51. DataObjectQuery
Thunderstruck

52. DataObjectQuery
var allCars = Select.All();
var lotusCars = Select.All("WHERE Name Like '%Lotus%'");
var newerCar = Select.First("ORDER BY ModelYear DESC");

53. DataObjectQuery
Parameters Binding works here.

54. DataObjectQuery
var queryCar = new { Name = "Lotus Esprit" };
var cars = Select.All("WHERE Name = @Name", queryCar);

55. Transactional DataObjectQuery
Many times is necessary get data in a
transaction scope, with Thunderstruck this
means in a DataContext.

56. Transactional DataObjectQuery
Select.With(context).First("ORDER BY ModelYear DESC");

57. Transactional DataObjectQuery
Done.

58. Custom DataObjects
Thunderstruck

59. Custom DataObjects
If, for example, TB_CARS is the
name of the table of cars...

60. Custom DataObjectCommand
new DataObjectCommand<Car>("TB_CAR");

61. Custom DataObjectQuery
Data query is a little different, because you
can/need customizing the query projection.

62. Custom DataObjectQuery
new DataObjectQuery<Car>("Name, ModelYear FROM TB_CAR");

63. Custom DataObjectQuery
With the customized projection is possible
to make sql joins, giving more flexibility
to queries, like Views.

64. Custom DataObjectQuery
But, in most cases you just need the
projection with the defaults fields.

65. Custom DataObjectQuery
new DataObjectQuery<Car>("{0} FROM TB_CAR");

66. Thunderstruck
A really fast way to access databases

67. Thunderstruck
Source, download and more info at Github.
http://github.com/wagnerandrade/Thunderstruck

68. Thunderstruck
Thanks, that's all folks!